From 8fb0c2112b0edfb894d0fe02247407929a76a30a Mon Sep 17 00:00:00 2001 From: John Blum Date: Thu, 17 Sep 2020 17:48:57 -0700 Subject: [PATCH] Replace references to 'Pivotal GemFire' with 'VMware Tanzu GemFire'. Fix compiler syntax errors in code snippets. Introduce documentation variables where applicable. Format source code. Optimize imports. --- CONTRIBUTING.adoc | 4 +- README.adoc | 36 +-- build.gradle | 2 +- .../spring-gemfire-starter-actuator.gradle | 2 +- .../spring-gemfire-starter-logging.gradle | 2 +- .../spring-gemfire-starter-session.gradle | 2 +- .../spring-gemfire-starter-test.gradle | 2 +- .../spring-gemfire-starter.gradle | 2 +- ...GeodeHealthIndicatorAutoConfiguration.java | 2 +- ...BaseGeodeHealthIndicatorConfiguration.java | 2 +- ...ientCacheHealthIndicatorConfiguration.java | 2 +- ...PeerCacheHealthIndicatorConfiguration.java | 4 +- .../CacheNameAutoConfiguration.java | 4 +- .../GemFirePropertiesAutoConfiguration.java | 2 +- .../LoggingAutoConfiguration.java | 2 +- .../RegionTemplateAutoConfiguration.java | 4 +- .../SpringSessionAutoConfiguration.java | 2 +- ...ingSessionPropertiesAutoConfiguration.java | 4 +- .../configuration/GemFireProperties.java | 4 +- .../SpringSessionProperties.java | 6 +- .../support/CacheProperties.java | 9 +- .../support/CacheServerProperties.java | 7 +- .../support/ClientCacheProperties.java | 5 +- .../support/ClientSecurityProperties.java | 9 +- .../support/ClusterProperties.java | 7 +- .../support/DiskStoreProperties.java | 6 +- .../support/EntityProperties.java | 7 +- .../support/LocatorProperties.java | 8 +- .../support/LoggingProperties.java | 5 +- .../support/ManagementProperties.java | 6 +- .../support/ManagerProperties.java | 6 +- .../configuration/support/PdxProperties.java | 17 +- .../support/PeerCacheProperties.java | 7 +- .../support/PeerSecurityProperties.java | 9 +- .../configuration/support/PoolProperties.java | 6 +- .../support/SecurityProperties.java | 7 +- .../support/ServiceProperties.java | 5 +- .../configuration/support/SslProperties.java | 5 +- .../boot/autoconfigure/package-info.java | 2 +- .../EnableSubscriptionConfiguration.java | 4 +- ...itional-spring-configuration-metadata.json | 10 +- ...atureReadingsContinuousQueriesHandler.java | 2 +- ...AutoConfiguredCachingIntegrationTests.java | 4 +- ...allyConfiguredCachingIntegrationTests.java | 6 +- ...ePropertiesPrecedenceIntegrationTests.java | 8 +- ...iguredContinuousQueryIntegrationTests.java | 2 +- ...redFunctionExecutionsIntegrationTests.java | 2 +- .../function/executions/Calculator.java | 4 +- ...gingAutoConfigurationIntegrationTests.java | 4 +- ...onfiguredRepositoriesIntegrationTests.java | 3 +- .../repository/repo/CustomerRepository.java | 3 +- ...dCloudSecurityContextIntegrationTests.java | 4 +- ...HybridSecurityContextIntegrationTests.java | 3 +- ...dLocalSecurityContextIntegrationTests.java | 4 +- .../AutoConfiguredSslIntegrationTests.java | 2 +- ...figuredSessionCachingIntegrationTests.java | 7 +- ...figuredSessionCachingIntegrationTests.java | 4 +- ...figuredSessionCachingIntegrationTests.java | 2 +- ...pertiesSessionCachingIntegrationTests.java | 5 +- ...ationOfSessionCachingIntegrationTests.java | 5 +- ...application-gemfire-config-test.properties | 2 +- .../application-security-cloud.properties | 2 +- .../application-security-hybrid.properties | 2 +- ...plication-security-local-client.properties | 2 +- ...plication-security-local-server.properties | 2 +- .../application-security-multi.properties | 2 +- ...application-session-config-test.properties | 2 +- .../test/resources/application-ssl.properties | 2 +- spring-geode-docs/spring-geode-docs.gradle | 2 +- .../src/docs/asciidoc/_includes/appendix.adoc | 122 ++++---- .../_includes/clientcache-applications.adoc | 86 +++--- .../docs/asciidoc/_includes/cloudfoundry.adoc | 41 ++- .../_includes/configuration-annotations.adoc | 31 +- .../_includes/configuration-declarative.adoc | 88 +++--- .../_includes/configuration-externalized.adoc | 23 +- .../_includes/configuration-properties.adoc | 19 +- .../asciidoc/_includes/continuous-query.adoc | 26 +- .../_includes/data-serialization.adoc | 29 +- .../docs/asciidoc/_includes/functions.adoc | 19 +- .../_includes/gemfire-properties.adoc | 2 +- .../asciidoc/_includes/geode-api-ext.adoc | 2 +- .../src/docs/asciidoc/_includes/logging.adoc | 26 +- .../docs/asciidoc/_includes/repositories.adoc | 13 +- .../src/docs/asciidoc/_includes/samples.adoc | 11 +- .../docs/asciidoc/_includes/templates.adoc | 33 +-- .../docs/asciidoc/guides/caching-inline.adoc | 15 +- .../asciidoc/guides/caching-look-aside.adoc | 22 +- .../docs/asciidoc/guides/caching-near.adoc | 2 +- .../docs/asciidoc/guides/getting-started.adoc | 140 ++++----- .../src/docs/asciidoc/index-docinfo.xml | 2 +- .../src/docs/asciidoc/index.adoc | 7 +- ...ringBootApacheGeodeLocatorApplication.java | 2 +- .../resources/application-security.properties | 2 +- .../src/main/resources/application.properties | 2 +- .../cache/support/CacheWriterSupport.java | 2 +- .../RepositoryCacheLoaderWriterSupport.java | 2 +- .../ClusterAvailableConfiguration.java | 2 +- .../ClusterNotAvailableConfiguration.java | 2 +- .../config/annotation/EnableClusterAware.java | 5 +- .../annotation/EnableSecurityManager.java | 2 +- .../EnableSecurityManagerProxy.java | 2 +- .../annotation/GroupsConfiguration.java | 7 +- .../annotation/LocatorsConfiguration.java | 10 +- .../annotation/MemberNameConfiguration.java | 7 +- .../annotation/UseDistributedSystemId.java | 4 +- .../geode/config/annotation/UseGroups.java | 4 +- .../geode/config/annotation/UseLocators.java | 2 +- .../config/annotation/UseMemberName.java | 8 +- ...bleAnnotationConfigApplicationContext.java | 8 +- .../core/env/support/CloudCacheService.java | 16 +- ...onExecutionAutoConfigurationRegistrar.java | 4 +- .../support/SecurityManagerProxy.java | 8 +- .../support/SecurityManagerSupport.java | 7 +- spring-geode/src/main/resources/changelog.txt | 274 +++++++++--------- ...vailableConfigurationIntegrationTests.java | 14 +- ...vailableConfigurationIntegrationTests.java | 2 +- ...LocatorsConfigurationIntegrationTests.java | 2 +- 117 files changed, 712 insertions(+), 776 deletions(-) diff --git a/CONTRIBUTING.adoc b/CONTRIBUTING.adoc index cdec9b29..6e383b52 100644 --- a/CONTRIBUTING.adoc +++ b/CONTRIBUTING.adoc @@ -1,6 +1,6 @@ -= Contributing to Spring Boot for Apache Geode & Pivotal GemFire += Contributing to Spring Boot for Apache Geode & VMware Tanzu GemFire -Spring Boot for Apache Geode & Pivotal GemFire (SBDG) is released under the Apache 2.0 license. If you would like to +Spring Boot for Apache Geode & VMware Tanzu GemFire (SBDG) is released under the Apache 2.0 license. If you would like to contribute something, or simply want to hack on the code this document should help you get started. == Sign the Contributor License Agreement diff --git a/README.adoc b/README.adoc index e4121360..b5fbb2ab 100644 --- a/README.adoc +++ b/README.adoc @@ -1,45 +1,45 @@ image:https://api.travis-ci.org/spring-projects/spring-boot-data-geode.svg?branch=master["Build Status", link="https://travis-ci.org/spring-projects/spring-boot-data-geode"] [[about]] -== Spring Boot for Apache Geode & Pivotal GemFire +== Spring Boot for Apache Geode & VMware Tanzu GemFire -_Spring Boot for Apache Geode & Pivotal GemFire_ extends https://projects.spring.io/spring-boot/[_Spring Boot_] with +_Spring Boot for Apache Geode & VMware Tanzu GemFire_ extends https://projects.spring.io/spring-boot/[_Spring Boot_] with _auto-configuration_ support as well as other _convention or configuration_ features to simplify the development -of _Spring_ applications using either https://geode.apache.org/[Apache Geode] or https://pivotal.io/pivotal-gemfire[Pivotal GemFire] +of _Spring_ applications using either https://geode.apache.org/[Apache Geode] or https://pivotal.io/pivotal-gemfire[VMware Tanzu GemFire] in a _Spring_ context. This project builds on both https://github.com/spring-projects/spring-data-geode[_Spring Data for Apache Geode_] -and https://projects.spring.io/spring-data-gemfire/[_Spring Data for Pivotal GemFire_] +and https://projects.spring.io/spring-data-gemfire/[_Spring Data for VMware Tanzu GemFire_] as well as https://spring.io/projects/spring-boot[Spring Boot]. [[project-goals]] === Project Goals This project adds _Spring Boot_ **auto-configuration** support for both https://geode.apache.org/[Apache Geode] -and https://pivotal.io/pivotal-gemfire[Pivotal GemFire]. +and https://pivotal.io/pivotal-gemfire[VMware Tanzu GemFire]. Among other things, this project builds on https://projects.spring.io/spring-boot/[_Spring Boot_] -as well as https://projects.spring.io/spring-data-gemfire/[_Spring Data for Apache Geode & Pivotal GemFire_] +as well as https://projects.spring.io/spring-data-gemfire/[_Spring Data for Apache Geode & VMware Tanzu GemFire_] and additionally offers... -1. _Auto-configures_ an _Apache Geode_ or _Pivotal GemFire_ (PCC) +1. _Auto-configures_ an _Apache Geode_ or _VMware Tanzu GemFire_ (PCC) https://geode.apache.org/releases/latest/javadoc/org/apache/geode/cache/client/ClientCache.html[ClientCache] -instance automatically when either _Spring Data for Apache Geode_ or _Spring Data for Pivotal GemFire_ +instance automatically when either _Spring Data for Apache Geode_ or _Spring Data for VMware Tanzu GemFire_ are on the application's CLASSPATH. -2. _Auto-configures_ either _Apache Geode_ or _Pivotal GemFire_ (PCC) as a _caching provider_ in +2. _Auto-configures_ either _Apache Geode_ or _VMware Tanzu GemFire_ (PCC) as a _caching provider_ in https://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#cache[_Spring's Cache Abstraction_] -when either _Spring Data for Apache Geode_ or _Spring Data for Pivotal GemFire_ are on the application's CLASSPATH. +when either _Spring Data for Apache Geode_ or _Spring Data for VMware Tanzu GemFire_ are on the application's CLASSPATH. -3. _Auto-configures_ _Spring Data for Apache Geode_ or _Spring Data for Pivotal GemFire_ +3. _Auto-configures_ _Spring Data for Apache Geode_ or _Spring Data for VMware Tanzu GemFire_ https://docs.spring.io/spring-data-gemfire/docs/current/reference/html/#gemfire-repositories[Repositories] -when _Spring Data for Apache Geode_ or _Spring Data for Pivotal GemFire_ are on the application's CLASSPATH +when _Spring Data for Apache Geode_ or _Spring Data for VMware Tanzu GemFire_ are on the application's CLASSPATH and _Spring Boot_ detects SDG _Repositories_ in your _Spring Boot_ application. -4. Provides additional support for _Spring Boot_/_Spring Data for Apache Geode_/_Pivotal GemFire_ applications +4. Provides additional support for _Spring Boot_/_Spring Data for Apache Geode_/_VMware Tanzu GemFire_ applications deployed to PCF using Pivotal Cloud Cache (PCC). Additionally, if your application requires (HTTP) Session State Caching services, you can also take advantage of -https://github.com/spring-projects/spring-session-data-geode[_Spring Session for Apache Geode/Pivotal GemFire_]. +https://github.com/spring-projects/spring-session-data-geode[_Spring Session for Apache Geode/VMware Tanzu GemFire_]. This, along with many other benefits, are provided by this project. @@ -66,17 +66,17 @@ This, along with many other benefits, are provided by this project. === Examples The single, most relevant "_source of truth_" on how to get started quickly and effectively, using Spring Boot -for Apache Geode & Pivotal GemFire (SBDG) to solve problems, is to start with the +for Apache Geode & VMware Tanzu GemFire (SBDG) to solve problems, is to start with the https://docs.spring.io/spring-boot-data-geode-build/current/reference/html5/#geode-samples[Samples]. There, you will find different examples with documentation and code showing you how to use SBDG to appropriately handle specific application concerns, like Caching. You can find an example of using SBDG in the Pivotal Cloud Cache (PCC) https://github.com/pivotal-cf/PCC-Sample-App-PizzaStore[Pizza Store] -GitHub repository, which is a Spring Boot, Pivotal GemFire `ClientCache` application that connects to PCC when the app +GitHub repository, which is a Spring Boot, VMware Tanzu GemFire `ClientCache` application that connects to PCC when the app is deployed to PCF. The https://github.com/jxblum/contacts-application/tree/master/boot-example[boot-example] found in the -_Contacts Application Reference Implementation_ for _Spring Data for Apache Geode & Pivotal GemFire_ (SDG) uses SBDG +_Contacts Application Reference Implementation_ for _Spring Data for Apache Geode & VMware Tanzu GemFire_ (SDG) uses SBDG to manage Books in a _System of Record_ Use Case. Then, there is a series of examples that walks a user through a series of steps starting by building a simple, @@ -112,5 +112,5 @@ Please see our https://github.com/spring-projects/spring-boot-data-geode/securit [[license]] == License -_Spring Boot_, _Spring Boot for Apache Geode_ and _Spring Boot for Pivotal GemFire_ is Open Source Software +_Spring Boot_, _Spring Boot for Apache Geode_ and _Spring Boot for VMware Tanzu GemFire_ is Open Source Software released under the https://www.apache.org/licenses/LICENSE-2.0.html[Apache 2.0 license]. diff --git a/build.gradle b/build.gradle index 75b69119..71cfaa65 100644 --- a/build.gradle +++ b/build.gradle @@ -12,7 +12,7 @@ buildscript { apply plugin: 'io.spring.convention.root' group = 'org.springframework.geode' -description = 'Spring Boot for Apache Geode & Pivotal GemFire' +description = 'Spring Boot for Apache Geode & VMware Tanzu GemFire' //ext['spring.version'] = "$springVersion" //ext['spring-framework.version'] = "$springVersion" diff --git a/spring-gemfire-starter-actuator/spring-gemfire-starter-actuator.gradle b/spring-gemfire-starter-actuator/spring-gemfire-starter-actuator.gradle index d56b6c75..932cc048 100644 --- a/spring-gemfire-starter-actuator/spring-gemfire-starter-actuator.gradle +++ b/spring-gemfire-starter-actuator/spring-gemfire-starter-actuator.gradle @@ -1,7 +1,7 @@ apply plugin: 'io.spring.convention.spring-module' apply from: MAVEN_POM_EDITOR_GRADLE -description = "Spring Boot Actuator Starter for Pivotal GemFire" +description = "Spring Boot Actuator Starter for VMware Tanzu GemFire" dependencies { diff --git a/spring-gemfire-starter-logging/spring-gemfire-starter-logging.gradle b/spring-gemfire-starter-logging/spring-gemfire-starter-logging.gradle index afe6d363..275c0609 100644 --- a/spring-gemfire-starter-logging/spring-gemfire-starter-logging.gradle +++ b/spring-gemfire-starter-logging/spring-gemfire-starter-logging.gradle @@ -1,7 +1,7 @@ apply plugin: 'io.spring.convention.spring-module' apply from: MAVEN_POM_EDITOR_GRADLE -description = "Spring Boot Logging Starter for Pivotal GemFire with Logback as the logging provider and adaptation of Log4j to SLF4J" +description = "Spring Boot Logging Starter for VMware Tanzu GemFire with Logback as the logging provider and adaptation of Log4j to SLF4J" dependencies { diff --git a/spring-gemfire-starter-session/spring-gemfire-starter-session.gradle b/spring-gemfire-starter-session/spring-gemfire-starter-session.gradle index 1e468d99..f6402567 100644 --- a/spring-gemfire-starter-session/spring-gemfire-starter-session.gradle +++ b/spring-gemfire-starter-session/spring-gemfire-starter-session.gradle @@ -1,7 +1,7 @@ apply plugin: 'io.spring.convention.spring-module' apply from: MAVEN_POM_EDITOR_GRADLE -description = "Spring Boot Starter for Spring Session using Pivotal GemFire" +description = "Spring Boot Starter for Spring Session using VMware Tanzu GemFire" dependencies { diff --git a/spring-gemfire-starter-test/spring-gemfire-starter-test.gradle b/spring-gemfire-starter-test/spring-gemfire-starter-test.gradle index 4a0b7100..c7dc2358 100644 --- a/spring-gemfire-starter-test/spring-gemfire-starter-test.gradle +++ b/spring-gemfire-starter-test/spring-gemfire-starter-test.gradle @@ -1,7 +1,7 @@ apply plugin: 'io.spring.convention.spring-module' apply from: MAVEN_POM_EDITOR_GRADLE -description = "Spring Boot Test Starter for Pivotal GemFire" +description = "Spring Boot Test Starter for VMware Tanzu GemFire" dependencies { diff --git a/spring-gemfire-starter/spring-gemfire-starter.gradle b/spring-gemfire-starter/spring-gemfire-starter.gradle index c15ce7eb..82aed97c 100644 --- a/spring-gemfire-starter/spring-gemfire-starter.gradle +++ b/spring-gemfire-starter/spring-gemfire-starter.gradle @@ -1,7 +1,7 @@ apply plugin: 'io.spring.convention.spring-module' apply from: MAVEN_POM_EDITOR_GRADLE -description = "Spring Boot Starter for Pivotal GemFire" +description = "Spring Boot Starter for VMware Tanzu GemFire" dependencies { diff --git a/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/GeodeHealthIndicatorAutoConfiguration.java b/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/GeodeHealthIndicatorAutoConfiguration.java index b3a861b5..e478d84c 100644 --- a/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/GeodeHealthIndicatorAutoConfiguration.java +++ b/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/GeodeHealthIndicatorAutoConfiguration.java @@ -32,7 +32,7 @@ import org.springframework.geode.boot.actuate.autoconfigure.config.PeerCacheHeal import org.springframework.geode.boot.autoconfigure.ClientCacheAutoConfiguration; /** - * Spring Boot {@link EnableAutoConfiguration auto-configuration} for Apache Geode/Pivotal GemFire + * Spring Boot {@link EnableAutoConfiguration auto-configuration} for Apache Geode * {@link HealthIndicator HealthIndicators}. * * @author John Blum diff --git a/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/BaseGeodeHealthIndicatorConfiguration.java b/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/BaseGeodeHealthIndicatorConfiguration.java index 538d7ded..78298e65 100644 --- a/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/BaseGeodeHealthIndicatorConfiguration.java +++ b/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/BaseGeodeHealthIndicatorConfiguration.java @@ -29,7 +29,7 @@ import org.springframework.geode.boot.actuate.GeodeIndexesHealthIndicator; import org.springframework.geode.boot.actuate.GeodeRegionsHealthIndicator; /** - * Spring {@link Configuration @Configuration} class declaring Spring beans for general Apache Geode/Pivotal GemFire + * Spring {@link Configuration @Configuration} class declaring Spring beans for general Apache Geode * peer {@link Cache} and {@link ClientCache} {@link HealthIndicator HealthIndicators}. * * @author John Blum diff --git a/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/ClientCacheHealthIndicatorConfiguration.java b/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/ClientCacheHealthIndicatorConfiguration.java index 61428801..da1b2ca2 100644 --- a/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/ClientCacheHealthIndicatorConfiguration.java +++ b/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/ClientCacheHealthIndicatorConfiguration.java @@ -33,7 +33,7 @@ import org.springframework.geode.boot.actuate.GeodeContinuousQueriesHealthIndica import org.springframework.geode.boot.actuate.GeodePoolsHealthIndicator; /** - * Spring {@link Configuration @Configuration} class declaring Spring beans for Apache Geode/Pivotal GemFire + * Spring {@link Configuration @Configuration} class declaring Spring beans for Apache Geode * {@link ClientCache} {@link HealthIndicator HealthIndicators}. * * @author John Blum diff --git a/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/PeerCacheHealthIndicatorConfiguration.java b/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/PeerCacheHealthIndicatorConfiguration.java index 0e3e7142..08d60717 100644 --- a/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/PeerCacheHealthIndicatorConfiguration.java +++ b/spring-geode-actuator-autoconfigure/src/main/java/org/springframework/geode/boot/actuate/autoconfigure/config/PeerCacheHealthIndicatorConfiguration.java @@ -43,8 +43,8 @@ import org.springframework.geode.core.util.ObjectUtils; import org.springframework.lang.Nullable; /** - * Spring {@link Configuration @Configuration} class declaring Spring beans for Apache Geode/Pivotal GemFire - * peer {@link Cache} {@link HealthIndicator HealthIndicators}. + * Spring {@link Configuration @Configuration} class declaring Spring beans for Apache Geode peer {@link Cache} + * {@link HealthIndicator HealthIndicators}. * * @author John Blum * @see org.apache.geode.cache.Cache diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/CacheNameAutoConfiguration.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/CacheNameAutoConfiguration.java index f8c2c232..55b701b6 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/CacheNameAutoConfiguration.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/CacheNameAutoConfiguration.java @@ -36,8 +36,8 @@ import org.springframework.util.StringUtils; /** * Spring Boot {@link EnableAutoConfiguration auto-configuration} class used to configure the Apache Geode - * / Pivotal GemFire {@link ClientCache} application or peer {@link Cache} member node name - * (i.e. {@literal gemfire.name}) with the Spring Boot {@literal spring.application.name} property. + * {@link ClientCache} application or peer {@link Cache} member node name (i.e. {@literal gemfire.name}) + * with the Spring Boot {@literal spring.application.name} property. * * @author John Blum * @see org.apache.geode.cache.Cache diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/GemFirePropertiesAutoConfiguration.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/GemFirePropertiesAutoConfiguration.java index 3ea0a3ca..533f526f 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/GemFirePropertiesAutoConfiguration.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/GemFirePropertiesAutoConfiguration.java @@ -30,7 +30,7 @@ import org.springframework.geode.boot.autoconfigure.configuration.GemFirePropert /** * Spring Boot {@link EnableAutoConfiguration auto-configuration} class used to configure Spring Boot * {@link ConfigurationProperties @ConfigurationProperites} classes and beans from the Spring {@link Environment} - * containing Apache Geode / Pivotal GemFire configuration properties. + * containing Apache Geode configuration properties. * * @author John Blum * @see org.apache.geode.cache.GemFireCache diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/LoggingAutoConfiguration.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/LoggingAutoConfiguration.java index c0c02313..ff1f4970 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/LoggingAutoConfiguration.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/LoggingAutoConfiguration.java @@ -26,7 +26,7 @@ import org.springframework.data.gemfire.CacheFactoryBean; import org.springframework.data.gemfire.config.annotation.EnableLogging; /** - * Spring Boot {@link EnableAutoConfiguration Auto-Configuration} for Apache Geode and Pivotal GemFire logging. + * Spring Boot {@link EnableAutoConfiguration Auto-Configuration} for Apache Geode logging. * * @author John Blum * @see org.springframework.boot.autoconfigure.EnableAutoConfiguration diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/RegionTemplateAutoConfiguration.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/RegionTemplateAutoConfiguration.java index 3e1df8de..b7b5b7f7 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/RegionTemplateAutoConfiguration.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/RegionTemplateAutoConfiguration.java @@ -65,8 +65,8 @@ import org.springframework.util.StringUtils; /** * Spring Boot {@link EnableAutoConfiguration auto-configuration} class used to configure a {@link GemfireTemplate} - * for each Apache Geode / Pivotal GemFire {@link Region} declared/defined in - * the Spring {@link ConfigurableApplicationContext} in order to perform {@link Region} data access operations. + * for each Apache Geode {@link Region} declared/defined in the Spring {@link ConfigurableApplicationContext} + * in order to perform {@link Region} data access operations. * * @author John Blum * @see org.apache.geode.cache.GemFireCache diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionAutoConfiguration.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionAutoConfiguration.java index 5a2fd4d8..67be3c41 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionAutoConfiguration.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionAutoConfiguration.java @@ -48,7 +48,7 @@ import org.springframework.util.StringUtils; /** * Spring Boot {@link EnableAutoConfiguration auto-configuration} for configuring either Apache Geode - * or Pivotal GemFire as an (HTTP) {@link Session} state management provider in Spring Session. + * as an (HTTP) {@link Session} state management provider in Spring Session. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionPropertiesAutoConfiguration.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionPropertiesAutoConfiguration.java index 1d673dfa..07c145ad 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionPropertiesAutoConfiguration.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/SpringSessionPropertiesAutoConfiguration.java @@ -32,8 +32,8 @@ import org.springframework.session.data.gemfire.config.annotation.web.http.GemFi /** * Spring Boot {@link EnableAutoConfiguration auto-configuration} class used to configure Spring Boot * {@link ConfigurationProperties @ConfigurationProperites} classes and beans from the Spring {@link Environment} - * containing Spring Session configuration properties used to configure either Apache Geode or Pivotal GemFire - * to manage (HTTP) Session state. + * containing Spring Session configuration properties used to configure either Apache Geode to manage (HTTP) Session + * state. * * @author John Blum * @see org.apache.geode.cache.GemFireCache diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/GemFireProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/GemFireProperties.java index a0d9576b..1d85abd9 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/GemFireProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/GemFireProperties.java @@ -33,8 +33,8 @@ import org.springframework.geode.boot.autoconfigure.configuration.support.Securi import org.springframework.geode.boot.autoconfigure.configuration.support.ServiceProperties; /** - * Spring Boot {@link ConfigurationProperties} for well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * Spring Boot {@link ConfigurationProperties} for well-known, documented Spring Data for Apache Geode(SDG) + * {@link Properties}. * * This class assists the application developer in the auto-completion / content-assist of the well-known, documented * SDG {@link Properties}. diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/SpringSessionProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/SpringSessionProperties.java index 4736e3c1..7a698855 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/SpringSessionProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/SpringSessionProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration; import org.apache.geode.cache.RegionShortcut; @@ -23,9 +22,8 @@ import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.NestedConfigurationProperty; /** - * Spring Boot {@link ConfigurationProperties} used to configure Spring Session for Apache Geode or Pivotal GemFire - * (SSDG) in order to manage (HTTP) Session state with Spring Session, backed by either Apache Geode - * or Pivotal GemFire. + * Spring Boot {@link ConfigurationProperties} used to configure Spring Session for Apache Geode (SSDG) in order to + * manage (HTTP) Session state with Spring Session, backed by Apache Geode. * * @author John Blum * @see org.springframework.boot.context.properties.ConfigurationProperties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheProperties.java index 8a697a76..4c3cb1ed 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -27,11 +26,11 @@ import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.NestedConfigurationProperty; /** - * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire peer {@link Cache}, - * {@link ClientCache} and {@link CacheServer} objects. + * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode peer {@link Cache}, {@link ClientCache} + * and {@link CacheServer} objects. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheServerProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheServerProperties.java index f7065abb..8152a2e7 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheServerProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/CacheServerProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -25,10 +24,10 @@ import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.data.gemfire.server.SubscriptionEvictionPolicy; /** - * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire {@link CacheServer}. + * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode {@link CacheServer}. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientCacheProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientCacheProperties.java index 16b5d871..5e802053 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientCacheProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientCacheProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -23,9 +22,9 @@ import org.apache.geode.cache.client.ClientCache; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire {@link ClientCache}. + * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode {@link ClientCache}. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode * (SDG) {@link Properties}. * * @author John Blum diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientSecurityProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientSecurityProperties.java index 2e42a523..53f8dd5a 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientSecurityProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClientSecurityProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -23,11 +22,11 @@ import org.apache.geode.cache.client.ClientCache; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire {@link ClientCache} - * Security (authentication & authorization). + * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode {@link ClientCache} Security + * (authentication & authorization). * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClusterProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClusterProperties.java index f1fa45c0..a3678f55 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClusterProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ClusterProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -26,10 +25,10 @@ import org.springframework.boot.context.properties.ConfigurationProperties; /** * Spring Boot {@link ConfigurationProperties} used to configure the {@link DataPolicy} of all {@link Region Regions} - * in an Apache Geode / Pivotal GemFire cluster. + * in an Apache Geode cluster. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/DiskStoreProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/DiskStoreProperties.java index e04b57b8..ccd9b2ff 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/DiskStoreProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/DiskStoreProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -24,10 +23,9 @@ import org.apache.geode.cache.DiskStoreFactory; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire - * {@link DiskStore DiskStores}. + * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode {@link DiskStore DiskStores}. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode * (SDG) {@link Properties}. * * @author John Blum diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/EntityProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/EntityProperties.java index fba7e181..75dc4337 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/EntityProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/EntityProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -25,10 +24,10 @@ import org.springframework.boot.context.properties.ConfigurationProperties; /** * Spring Boot {@link ConfigurationProperties} used to configure the application base {@link Package package} * containing the application entity classes. The entity classes are then used to create and configure - * Apache Geode / Pivotal GemFire {@link Region Regions}. + * Apache Geode {@link Region Regions}. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LocatorProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LocatorProperties.java index 5176c6ae..50216694 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LocatorProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LocatorProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -23,14 +22,13 @@ import org.apache.geode.distributed.Locator; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure an embedded Apache Geode / Pivotal GemFire - * {@link Locator}. + * Spring Boot {@link ConfigurationProperties} used to configure an embedded Apache Geode {@link Locator}. * * A {@link Locator} enables location services used by nodes to join an existing cluster as a peer member * and is also used by clients to discover servers in the cluster. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LoggingProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LoggingProperties.java index 8a890ffd..6eff7494 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LoggingProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/LoggingProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -21,9 +20,9 @@ import java.util.Properties; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire logging. + * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode logging. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode * (SDG) {@link Properties}. * * @author John Blum diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagementProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagementProperties.java index 82ddea18..f8b7b038 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagementProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagementProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -21,10 +20,9 @@ import java.util.Properties; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire management services, - * such as HTTP. + * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode management services, such as HTTP. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode * (SDG) {@link Properties}. * * @author John Blum diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagerProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagerProperties.java index 673719fd..431b358d 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagerProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ManagerProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -21,12 +20,11 @@ import java.util.Properties; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure an embedded Apache Geode / Pivotal GemFire - * {@literal Manager}. + * Spring Boot {@link ConfigurationProperties} used to configure an embedded Apache Geode {@literal Manager}. * * A {@literal Manager} allows users to manage a cluster with tools like {@literal Gfsh} or {@literal Pulse}. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode * (SDG) {@link Properties}. * * @author John Blum diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PdxProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PdxProperties.java index 3d478c33..3335b3c2 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PdxProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PdxProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -21,17 +20,15 @@ import java.util.Properties; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire - * {@literal PDX} serialization. + * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode {@literal PDX} serialization. * - * PDX serialization is an alternative serialization format to Java Serialization provided by - * Apache Geode / Pivotal GemFire. PDX enables interoperability with native language clients (e.g. C++), - * enables objects stored in GemFire/Geode to be queried without causing deserialization and is a more efficient - * format than Java Serialization. While PDX is more robust in some ways, it is less robust in others. For example, - * PDX does not handle cyclic references in the object graph. + * PDX serialization is an alternative serialization format to Java Serialization provided by Apache Geode. PDX enables + * interoperability with native language clients (e.g. C++), enables objects stored in GemFire/Geode to be queried + * without causing deserialization and is a more efficient format than Java Serialization. While PDX is more robust + * in some ways, it is less robust in others. For example, PDX does not handle cyclic references in the object graph. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerCacheProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerCacheProperties.java index 5155b794..eda42223 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerCacheProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerCacheProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -23,10 +22,10 @@ import org.apache.geode.cache.Cache; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire peer {@link Cache}. + * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode peer {@link Cache}. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerSecurityProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerSecurityProperties.java index 51c99cdb..e454908d 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerSecurityProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PeerSecurityProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -23,11 +22,11 @@ import org.apache.geode.cache.Cache; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire peer {@link Cache} - * Security (authentication & authorization). + * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode peer {@link Cache} Security + * (authentication & authorization). * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PoolProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PoolProperties.java index ac0f4363..7b1689e8 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PoolProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/PoolProperties.java @@ -23,10 +23,10 @@ import org.apache.geode.cache.client.PoolFactory; import org.springframework.boot.context.properties.ConfigurationProperties; /** - * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode / Pivotal GemFire peer {@link Pool}. + * Spring Boot {@link ConfigurationProperties} used to configure an Apache Geode client {@link Pool}. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SecurityProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SecurityProperties.java index 6293d8eb..4ffcba19 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SecurityProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SecurityProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -22,13 +21,13 @@ import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.NestedConfigurationProperty; /** - * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire Security. + * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode Security. * * Security configuration covers Authentication & Authorization (AUTH) as well as Secure Transport using SSL * (i.e. securing data in motion). Securing data at rest (e.g. disk based encryption) is not yet supported. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire - * (SDG) {@link Properties}. + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode (SDG) + * {@link Properties}. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ServiceProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ServiceProperties.java index 2c3c704a..27df74dd 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ServiceProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/ServiceProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -22,12 +21,12 @@ import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.data.gemfire.config.annotation.EnableMemcachedServer; /** - * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire embedded services. + * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode embedded services. * * Currently, the supported embedded services include HTTP service (Jetty), Memcached (protocol) server * and a Redis (protocol) server. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode * (SDG) {@link Properties}. * * @author John Blum diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SslProperties.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SslProperties.java index d3be447c..cce95e4b 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SslProperties.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/configuration/support/SslProperties.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.configuration.support; import java.util.Properties; @@ -23,12 +22,12 @@ import org.springframework.boot.context.properties.NestedConfigurationProperty; import org.springframework.data.gemfire.config.annotation.EnableSsl; /** - * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode / Pivotal GemFire Socket layer SSL. + * Spring Boot {@link ConfigurationProperties} used to configure Apache Geode Socket layer SSL. * * The SSL configuration is used to secure communications and data in motion between clients and servers * as well as between peers in a cluster. * - * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode/Pivotal GemFire + * The configuration {@link Properties} are based on well-known, documented Spring Data for Apache Geode * (SDG) {@link Properties}. * * @author John Blum diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/package-info.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/package-info.java index b4e974b1..7392792e 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/package-info.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/package-info.java @@ -15,6 +15,6 @@ */ /** - * Spring Boot auto-configuration for Apache Geode & Pivotal GemFire. + * Spring Boot auto-configuration for Apache Geode. */ package org.springframework.geode.boot.autoconfigure; diff --git a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/support/EnableSubscriptionConfiguration.java b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/support/EnableSubscriptionConfiguration.java index ca1ecd08..aca04053 100644 --- a/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/support/EnableSubscriptionConfiguration.java +++ b/spring-geode-autoconfigure/src/main/java/org/springframework/geode/boot/autoconfigure/support/EnableSubscriptionConfiguration.java @@ -28,8 +28,8 @@ import org.springframework.data.gemfire.config.annotation.ClientCacheConfigurer; import org.springframework.data.gemfire.config.annotation.PoolConfigurer; /** - * A Spring {@link Configuration} class used to enable subscription on the Apache Geode & Pivotal GemFire - * {@literal DEFAULT} {@link Pool} as well as the SDG {@literal gemfirePool} {@link Pool}, only. + * A Spring {@link Configuration} class used to enable subscription on the Apache Geode {@literal DEFAULT} {@link Pool} + * as well as the SDG {@literal gemfirePool} {@link Pool}, only. * * @author John Blum * @see org.apache.geode.cache.client.Pool diff --git a/spring-geode-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json b/spring-geode-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json index 2f05d405..f2c891f6 100644 --- a/spring-geode-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json +++ b/spring-geode-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json @@ -88,7 +88,7 @@ { "name": "session", "type": "org.springframework.geode.boot.autoconfigure.configuration.support.SpringSessionProperties", - "description": "Configuration properties for Spring Session backed by Apache Geode or Pivotal GemFire." + "description": "Configuration properties for Spring Session backed by Apache Geode." }, { "name": "ssl", @@ -100,7 +100,7 @@ { "name": "spring.data.gemfire.name", "type": "java.lang.String", - "description": "Name of the Apache Geode / Pivotal GemFire member." + "description": "Name of the Apache Geode member." }, { "name": "spring.data.gemfire.locators", @@ -149,7 +149,7 @@ "name": "spring.data.gemfire.cache.log-level", "type": "java.lang.String", "default": "config", - "description": "Configure the log-level of an Apache Geode / Pivotal GemFire cache." + "description": "Configure the log-level of an Apache Geode cache." }, { "name": "spring.data.gemfire.cache.name", @@ -405,7 +405,7 @@ "name": "spring.data.gemfire.logging.level", "type": "java.lang.String", "default": "config", - "description": "Configures the log-level of an Apache Geode / Pivotal GemFire cache; Alias for 'spring.data.gemfire.cache.log-level'." + "description": "Configures the log-level of an Apache Geode cache; Alias for 'spring.data.gemfire.cache.log-level'." }, { "name": "spring.data.gemfire.logging.log-disk-space-limit", @@ -840,7 +840,7 @@ "name": "spring.data.gemfire.service.http.dev-rest-api-start", "type": "java.lang.Boolean", "default": false, - "description": "Configures whether to start the Developer REST API web service. A full installation of Apache Geode or Pivotal GemFire is required and you must set the $GEODE environment variable." + "description": "Configures whether to start the Developer REST API web service. A full installation of Apache Geode is required and you must set the $GEODE environment variable." }, { "name": "spring.data.gemfire.service.memcached.port", diff --git a/spring-geode-autoconfigure/src/test/java/example/geode/query/cq/event/TemperatureReadingsContinuousQueriesHandler.java b/spring-geode-autoconfigure/src/test/java/example/geode/query/cq/event/TemperatureReadingsContinuousQueriesHandler.java index 199b5375..578850a4 100644 --- a/spring-geode-autoconfigure/src/test/java/example/geode/query/cq/event/TemperatureReadingsContinuousQueriesHandler.java +++ b/spring-geode-autoconfigure/src/test/java/example/geode/query/cq/event/TemperatureReadingsContinuousQueriesHandler.java @@ -26,7 +26,7 @@ import org.apache.geode.cache.query.CqEvent; import org.springframework.data.gemfire.listener.annotation.ContinuousQuery; /** - * The {@link TemperatureReadingsContinuousQueriesHandler} class is a POJO containing Apache Geode/Pivotal GemFire + * The {@link TemperatureReadingsContinuousQueriesHandler} class is a POJO containing Apache Geode * Continuous Query (CQ) definitions. * * @author John Blum diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/AutoConfiguredCachingIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/AutoConfiguredCachingIntegrationTests.java index 561ba8fe..f65e5c01 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/AutoConfiguredCachingIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/AutoConfiguredCachingIntegrationTests.java @@ -43,8 +43,8 @@ import example.app.books.model.Book; import example.app.books.service.support.CachingBookService; /** - * Integration tests testing the auto-configuration of Spring's Cache Abstraction with Apache Geode - * or Pivotal GemFire as the caching provider. + * Integration Tests testing the auto-configuration of Spring's Cache Abstraction with Apache Geode + * as the caching provider. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/ManuallyConfiguredCachingIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/ManuallyConfiguredCachingIntegrationTests.java index 20e0db2e..df709f68 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/ManuallyConfiguredCachingIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/caching/ManuallyConfiguredCachingIntegrationTests.java @@ -35,9 +35,9 @@ import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.junit4.SpringRunner; /** - * Integration tests for {@link CachingProviderAutoConfiguration} asserting that neither Apache Geode - * nor Pivotal GemFire is configured as the caching provider in Spring's Cache Abstraction when another - * caching provider (i.e. {@link CacheManager} bean) has been declared and configured. + * Integration Tests for {@link CachingProviderAutoConfiguration} asserting that Apache Geode is not configured as + * the caching provider in Spring's Cache Abstraction when another caching provider (i.e. {@link CacheManager} bean) + * has been declared and configured. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/configuration/GeodePropertiesVsSpringDataGeodePropertiesPrecedenceIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/configuration/GeodePropertiesVsSpringDataGeodePropertiesPrecedenceIntegrationTests.java index 5e954266..a9df2634 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/configuration/GeodePropertiesVsSpringDataGeodePropertiesPrecedenceIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/configuration/GeodePropertiesVsSpringDataGeodePropertiesPrecedenceIntegrationTests.java @@ -35,11 +35,11 @@ import org.springframework.test.context.ActiveProfiles; import org.springframework.test.context.junit4.SpringRunner; /** - * Integration Tests asserting and testing the precedence of GemFire, Spring and Spring Data for Apache Geode - * & Pivotal GemFire (SDG) {@link Properties} precedence. + * Integration Tests asserting and testing the precedence of GemFire, Spring and Spring Data for Apache Geode (SDG) + * {@link Properties} precedence. * - * Essentially, SDG {@link Properties} should take precedence over (i.e. override) both Spring And Apache Geode - * or Pivotal GemFire {@link Properties}. + * Essentially, SDG {@link Properties} should take precedence over (i.e. override) both Spring and Apache Geode + * {@link Properties}. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/cq/AutoConfiguredContinuousQueryIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/cq/AutoConfiguredContinuousQueryIntegrationTests.java index 39f9ea4a..6d69d103 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/cq/AutoConfiguredContinuousQueryIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/cq/AutoConfiguredContinuousQueryIntegrationTests.java @@ -54,7 +54,7 @@ import example.geode.query.cq.event.TemperatureReading; import example.geode.query.cq.event.TemperatureReadingsContinuousQueriesHandler; /** - * Integration Tests testing the auto-configuration of Apache Geode/Pivotal GemFire Continuous Query. + * Integration Tests testing the auto-configuration of Apache Geode Continuous Query. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/AutoConfiguredFunctionExecutionsIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/AutoConfiguredFunctionExecutionsIntegrationTests.java index d2bc7dc1..d3397081 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/AutoConfiguredFunctionExecutionsIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/AutoConfiguredFunctionExecutionsIntegrationTests.java @@ -42,7 +42,7 @@ import org.springframework.test.context.junit4.SpringRunner; import org.springframework.util.Assert; /** - * Integration Tests testing the auto-configuration of Spring Data for Apache Geode/Pivotal GemFire + * Integration Tests testing the auto-configuration of Spring Data for Apache Geode * Function implementations and executions support. * * @author John Blum diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/executions/Calculator.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/executions/Calculator.java index 7ada4b42..4401d292 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/executions/Calculator.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/function/executions/Calculator.java @@ -13,20 +13,18 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.function.executions; import org.springframework.data.gemfire.function.annotation.OnMember; /** - * The {@link Calculator} interface defines Apache Geode/Pivotal GemFire Functions. + * The {@link Calculator} interface defines Apache Geode Functions. * * @author John Blum * @see org.springframework.data.gemfire.function.annotation.OnRegion * @since 1.0.0 */ @OnMember(groups = "test") -@SuppressWarnings("all") // TODO change Function returns type when SDG properly handles Function method return types/values public interface Calculator { diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/logging/LoggingAutoConfigurationIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/logging/LoggingAutoConfigurationIntegrationTests.java index a5f0d7f1..9524b603 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/logging/LoggingAutoConfigurationIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/logging/LoggingAutoConfigurationIntegrationTests.java @@ -33,8 +33,8 @@ import org.springframework.geode.util.GeodeConstants; import org.springframework.test.context.junit4.SpringRunner; /** - * Integration Tests asserting the configuration and behavior of Apache Geode & Pivotal GemFire logging - * when configured with Spring Boot auto-configuration. + * Integration Tests asserting the configuration and behavior of Apache Geode logging when configured with + * Spring Boot auto-configuration. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/AutoConfiguredRepositoriesIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/AutoConfiguredRepositoriesIntegrationTests.java index 4585dd3d..d952b61d 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/AutoConfiguredRepositoriesIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/AutoConfiguredRepositoriesIntegrationTests.java @@ -38,8 +38,7 @@ import org.springframework.geode.boot.autoconfigure.repository.service.CustomerS import org.springframework.test.context.junit4.SpringRunner; /** - * Integration Tests testing the auto-configuration of Spring Data Repositories backed by either Apache Geode - * or Pivotal GemFire. + * Integration Tests testing the auto-configuration of Spring Data Repositories backed by Apache Geode. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/repo/CustomerRepository.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/repo/CustomerRepository.java index 8bed7f60..0d106505 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/repo/CustomerRepository.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/repository/repo/CustomerRepository.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.boot.autoconfigure.repository.repo; import org.springframework.data.repository.CrudRepository; @@ -21,7 +20,7 @@ import org.springframework.geode.boot.autoconfigure.repository.model.Customer; /** * The {@link CustomerRepository} interface defines a Spring Data {@link CrudRepository} for performing basic CRUD - * and simple query data access operations on {@link Customer} objects stored in Apache Geode or Pivotal GemFire. + * and simple query data access operations on {@link Customer} objects stored in Apache Geode. * * @author John Blum * @see org.springframework.data.repository.CrudRepository diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/cloud/AutoConfiguredCloudSecurityContextIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/cloud/AutoConfiguredCloudSecurityContextIntegrationTests.java index f80140af..779b96ea 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/cloud/AutoConfiguredCloudSecurityContextIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/cloud/AutoConfiguredCloudSecurityContextIntegrationTests.java @@ -34,8 +34,8 @@ import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.junit4.SpringRunner; /** - * Integration Tests testing the auto-configuration of Apache Geode/Pivotal GemFire Security - * authentication/authorization in a cloud, managed context (e.g. Pivotal CloudFoundry) + * Integration Tests testing the auto-configuration of Apache Geode Security authentication/authorization in a cloud, + * managed context (e.g. CloudFoundry). * * @author John Blum * @see java.security.Principal diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/hybrid/AutoConfiguredHybridSecurityContextIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/hybrid/AutoConfiguredHybridSecurityContextIntegrationTests.java index b0157d5f..8bc57a7f 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/hybrid/AutoConfiguredHybridSecurityContextIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/hybrid/AutoConfiguredHybridSecurityContextIntegrationTests.java @@ -42,8 +42,7 @@ import org.springframework.test.context.junit4.SpringRunner; * Pivotal Cloud Cache (PCC) service instance. * * This Use Case is common when users want to deploy their Spring Boot, {@link ClientCache} apps to - * Pivotal CloudFoundry (PCF) however, want to connect those apps to an external Apache Geode or Pivotal GemFire - * cluster. + * Pivotal CloudFoundry (PCF) however, want to connect those apps to an external Apache Geode cluster. * * @author John Blum * @see java.util.Properties diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/local/AutoConfiguredLocalSecurityContextIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/local/AutoConfiguredLocalSecurityContextIntegrationTests.java index d4ef8fee..93fba130 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/local/AutoConfiguredLocalSecurityContextIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/auth/local/AutoConfiguredLocalSecurityContextIntegrationTests.java @@ -31,8 +31,8 @@ import org.springframework.test.context.ActiveProfiles; import org.springframework.test.context.junit4.SpringRunner; /** - * Integration Tests testing the auto-configuration of Apache Geode/Pivotal GemFire Security - * authentication/authorization in a local, non-managed context. + * Integration Tests testing the auto-configuration of Apache Geode Security authentication/authorization in a local, + * non-managed context. * * @author John Blum * @see java.security.Principal diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/ssl/AutoConfiguredSslIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/ssl/AutoConfiguredSslIntegrationTests.java index 7d09f819..c429d932 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/ssl/AutoConfiguredSslIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/security/ssl/AutoConfiguredSslIntegrationTests.java @@ -53,7 +53,7 @@ import example.echo.config.EchoClientConfiguration; import example.echo.config.EchoServerConfiguration; /** - * Integration Tests testing the auto-configuration of Apache Geode/Pivotal GemFire SSL. + * Integration Tests testing the auto-configuration of Apache Geode SSL. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/AutoConfiguredSessionCachingIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/AutoConfiguredSessionCachingIntegrationTests.java index f127b69e..cd251c64 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/AutoConfiguredSessionCachingIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/AutoConfiguredSessionCachingIntegrationTests.java @@ -42,11 +42,10 @@ import org.springframework.session.data.gemfire.config.annotation.web.http.GemFi import org.springframework.test.context.junit4.SpringRunner; /** - * Integration Tests for auto-configuration of Spring Session using either Apache Geode or Pivotal GemFire - * as the {@link Session} state management provider. + * Integration Tests for auto-configuration of Spring Session using either Apache Geode as the {@link Session} state + * management provider. * - * This test asserts that the Spring Boot auto-configuration properly configures Spring Session - * with either Apache Geode or Pivotal GemFire + * This test asserts that the Spring Boot auto-configuration properly configures Spring Session with Apache Geode. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/CustomConfiguredSessionCachingIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/CustomConfiguredSessionCachingIntegrationTests.java index 27448588..61b0e240 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/CustomConfiguredSessionCachingIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/CustomConfiguredSessionCachingIntegrationTests.java @@ -51,8 +51,8 @@ import org.springframework.web.context.ConfigurableWebApplicationContext; import org.springframework.web.context.support.GenericWebApplicationContext; /** - * Integration Test for the auto-configuration of Spring Session using either Apache Geode or Pivotal GemFire - * as the {@link Session} state management provider. + * Integration Test for the auto-configuration of Spring Session using Apache Geode as the {@link Session} state + * management provider. * * This test asserts that the Spring Boot auto-configuration can be customized using either {@link Properties} * or a {@link SpringSessionGemFireConfigurer}. diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredSessionCachingIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredSessionCachingIntegrationTests.java index 729d36d7..54f2fff6 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredSessionCachingIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredSessionCachingIntegrationTests.java @@ -41,7 +41,7 @@ import org.springframework.test.context.junit4.SpringRunner; /** * Integration Tests for auto-configuration of Spring Session using a custom Spring Session {@link Session} state - * management provider, asserting that neither Apache Geode nor Pivotal GemFire is configured. + * management provider, asserting that Apache Geode is configured. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredWithPropertiesSessionCachingIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredWithPropertiesSessionCachingIntegrationTests.java index 36ba738c..8ff4ec9b 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredWithPropertiesSessionCachingIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/ManuallyConfiguredWithPropertiesSessionCachingIntegrationTests.java @@ -35,10 +35,9 @@ import org.springframework.session.data.gemfire.config.annotation.web.http.GemFi import org.springframework.test.context.junit4.SpringRunner; /** - * Integration Tests asserting the configuration of Spring Session using Spring Boot's + * Integration Tests asserting the configuration of Spring Session using Spring Boot' * {@literal spring.session.store-type} configuration property set to {@literal none} - * and assert neither Apache Geode nor Pivotal GemFire was configured as the Session - * state management provider. + * and assert Apache Geode was not configured as the Session state management provider. * * @author John Blum * @see org.apache.geode.cache.GemFireCache diff --git a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/NoAutoConfigurationOfSessionCachingIntegrationTests.java b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/NoAutoConfigurationOfSessionCachingIntegrationTests.java index 06f88701..8e484fee 100644 --- a/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/NoAutoConfigurationOfSessionCachingIntegrationTests.java +++ b/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure/session/NoAutoConfigurationOfSessionCachingIntegrationTests.java @@ -32,9 +32,8 @@ import org.springframework.test.context.junit4.SpringRunner; import org.springframework.web.context.WebApplicationContext; /** - * Integration tests for {@link SpringSessionAutoConfiguration} asserting that Spring Session - * (for Apache Geode/Pivotal GemFire) is not auto-configured when the Spring {@link ApplicationContext} - * is not a {@link WebApplicationContext}. + * Integration tests for {@link SpringSessionAutoConfiguration} asserting that Spring Session (for Apache Geode) + * is not auto-configured when the Spring {@link ApplicationContext} is not a {@link WebApplicationContext}. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode-autoconfigure/src/test/resources/application-gemfire-config-test.properties b/spring-geode-autoconfigure/src/test/resources/application-gemfire-config-test.properties index ea6c0412..78569ffe 100644 --- a/spring-geode-autoconfigure/src/test/resources/application-gemfire-config-test.properties +++ b/spring-geode-autoconfigure/src/test/resources/application-gemfire-config-test.properties @@ -1,4 +1,4 @@ -# Spring Boot application.properties containing Spring Data for Apache Geode / Pivotal GemFire properties. +# Spring Boot application.properties containing Spring Data for Apache Geode properties. spring.data.gemfire.name=GemFirePropertiesIntegrationTests spring.data.gemfire.locators=localhost[11235],localhost[12480] diff --git a/spring-geode-autoconfigure/src/test/resources/application-security-cloud.properties b/spring-geode-autoconfigure/src/test/resources/application-security-cloud.properties index 9ebd74ea..d656a6aa 100644 --- a/spring-geode-autoconfigure/src/test/resources/application-security-cloud.properties +++ b/spring-geode-autoconfigure/src/test/resources/application-security-cloud.properties @@ -1,4 +1,4 @@ -# Spring Boot application.properties for testing Apache Geode/Pivotal GemFire Security in a cloud context. +# Spring Boot application.properties for testing Apache Geode Security in a cloud context. vcap.application.application_id=c50bb519-2739-4fa3-8750-02c051e35735 vcap.application.application_name=boot-test diff --git a/spring-geode-autoconfigure/src/test/resources/application-security-hybrid.properties b/spring-geode-autoconfigure/src/test/resources/application-security-hybrid.properties index 4adf0522..cc391ef0 100644 --- a/spring-geode-autoconfigure/src/test/resources/application-security-hybrid.properties +++ b/spring-geode-autoconfigure/src/test/resources/application-security-hybrid.properties @@ -1,4 +1,4 @@ -# Spring Boot application.properties used in server for testing Apache Geode/Pivotal GemFire Security in a hybrid cloud context. +# Spring Boot application.properties used in server for testing Apache Geode Security in a hybrid cloud context. test.security.context.username=phantom test.security.context.password=s3cr3t diff --git a/spring-geode-autoconfigure/src/test/resources/application-security-local-client.properties b/spring-geode-autoconfigure/src/test/resources/application-security-local-client.properties index 606716a6..c6f21c7c 100644 --- a/spring-geode-autoconfigure/src/test/resources/application-security-local-client.properties +++ b/spring-geode-autoconfigure/src/test/resources/application-security-local-client.properties @@ -1,4 +1,4 @@ -# Spring Boot application.properties used in client for testing Apache Geode/Pivotal GemFire Security in a local context. +# Spring Boot application.properties used in client for testing Apache Geode Security in a local context. spring.data.gemfire.security.username=ghostrider spring.data.gemfire.security.password=p@55w0rd diff --git a/spring-geode-autoconfigure/src/test/resources/application-security-local-server.properties b/spring-geode-autoconfigure/src/test/resources/application-security-local-server.properties index 1d5bd480..7628328e 100644 --- a/spring-geode-autoconfigure/src/test/resources/application-security-local-server.properties +++ b/spring-geode-autoconfigure/src/test/resources/application-security-local-server.properties @@ -1,4 +1,4 @@ -# Spring Boot application.properties used in server for testing Apache Geode/Pivotal GemFire Security in a local context. +# Spring Boot application.properties used in server for testing Apache Geode Security in a local context. test.security.context.username=ghostrider test.security.context.password=p@55w0rd diff --git a/spring-geode-autoconfigure/src/test/resources/application-security-multi.properties b/spring-geode-autoconfigure/src/test/resources/application-security-multi.properties index 46e0cc18..8f0004ef 100644 --- a/spring-geode-autoconfigure/src/test/resources/application-security-multi.properties +++ b/spring-geode-autoconfigure/src/test/resources/application-security-multi.properties @@ -1,4 +1,4 @@ -# Spring Boot application.properties used in server for testing Apache Geode/Pivotal GemFire Security in a multi-cloudcache service instance (PCF) context. +# Spring Boot application.properties used in server for testing Apache Geode Security in a multi-cloudcache service instance (PCF) context. test.security.context.username=master test.security.context.password=p@55w0rd diff --git a/spring-geode-autoconfigure/src/test/resources/application-session-config-test.properties b/spring-geode-autoconfigure/src/test/resources/application-session-config-test.properties index fd6f2bc6..a48fe87f 100644 --- a/spring-geode-autoconfigure/src/test/resources/application-session-config-test.properties +++ b/spring-geode-autoconfigure/src/test/resources/application-session-config-test.properties @@ -1,4 +1,4 @@ -# Spring Session for Apache Geode/Pivotal GemFire (Test) Properties +# Spring Session for Apache Geode (SSDG) Test Properties spring.session.data.gemfire.cache.client.pool.name=DEAD spring.session.data.gemfire.cache.client.region.shortcut=LOCAL diff --git a/spring-geode-autoconfigure/src/test/resources/application-ssl.properties b/spring-geode-autoconfigure/src/test/resources/application-ssl.properties index e3d7e0e2..27c3f5f3 100644 --- a/spring-geode-autoconfigure/src/test/resources/application-ssl.properties +++ b/spring-geode-autoconfigure/src/test/resources/application-ssl.properties @@ -1,4 +1,4 @@ -# Spring Boot application.properties for testing Apache Geode/Pivotal GemFire SSL +# Spring Boot application.properties for testing Apache Geode SSL spring.boot.data.gemfire.security.ssl.keystore.name=test-trusted.keystore spring.data.gemfire.security.ssl.keystore.password=s3cr3t diff --git a/spring-geode-docs/spring-geode-docs.gradle b/spring-geode-docs/spring-geode-docs.gradle index d9eaa897..9ab4fa9c 100644 --- a/spring-geode-docs/spring-geode-docs.gradle +++ b/spring-geode-docs/spring-geode-docs.gradle @@ -7,7 +7,7 @@ import org.apache.tools.ant.filters.ReplaceTokens apply plugin: 'io.spring.convention.docs' apply plugin: 'io.spring.convention.spring-test' -description = "Generate Javadoc and Reference Documentation on Spring Boot for Apache Geode & Pivotal GemFire" +description = "Generate Javadoc and Reference Documentation on Spring Boot for Apache Geode & VMware Tanzu GemFire" dependencies { diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/appendix.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/appendix.adoc index dc239de3..1edd5800 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/appendix.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/appendix.adoc @@ -1,8 +1,10 @@ [[appendix]] == Appendix +:geode-name: {apache-geode-name} +:gemfire-name: {pivotal-gemfire-name} +:cloud-cache-name: {pivotal-cloudcache-name} -The following appendices provide additional help while developing Spring Boot applications backed by Apache Geode -or Pivotal GemFire. +The following appendices provide additional help while developing Spring Boot applications backed by {geode-name}. _Table of Contents_ @@ -24,9 +26,9 @@ include::configuration-properties.adoc[leveloffset=+1] [[geode-auto-configuration-disable]] === Disabling Auto-configuration -If you would like to disable the _auto-configuration_ of any feature provided by Spring Boot for Apache Geode -or Pivotal GemFire, then you can specify the _auto-configuration_ class in the `exclude` attribute -of the `@SpringBootApplication` annotation, as follows: +If you would like to disable the _auto-configuration_ of any feature provided by Spring Boot for {geode-name}, +then you can specify the _auto-configuration_ class in the `exclude` attribute of the `@SpringBootApplication` +annotation, as follows: .Disable Auto-configuration of PDX [source,java] @@ -58,7 +60,7 @@ public class MySpringBootApplication { [[geode-auto-configuration-disable-classes]] ==== Complete Set of Auto-configuration Classes -The current set of _auto-configuration_ classes in Spring Boot for Apache Geode & Pivotal GemFire (SBDG) include: +The current set of _auto-configuration_ classes in Spring Boot for {geode-name} (SBDG) include: * `CacheNameAutoConfiguration` * `CachingProviderAutoConfiguration` @@ -77,30 +79,31 @@ The current set of _auto-configuration_ classes in Spring Boot for Apache Geode * `SslAutoConfiguration` [[geode-gemfire-switch]] -=== Switch from Apache Geode to Pivotal Cloud Cache (a.k.a. Pivotal GemFire) +=== Switch from {geode-name} to {gemfire-name} for VMs (formerly known as Pivotal Cloud Cache) -First, understand that {pivotal-gemfire-website}[Pivotal GemFire] is being succeeded by {pivotal-cloudcache-website}[Pivotal Cloud Cache] (PCC). -Therefore, all references to Pivotal GemFire implies for Pivotal Cloud Cache (PCC) as well. +First, understand that {pivotal-gemfire-website}[Pivotal GemFire] is being succeeded by +{pivotal-cloudcache-website}[Pivotal Cloud Cache] (PCC) or {cloud-cache-name}. Therefore, all references to +Pivotal GemFire implies for Pivotal Cloud Cache (PCC) or {cloud-cache-name} as well. -When it comes to Spring's support, whether you are developing with Open Source Software (OSS) {apache-geode-website}[Apache Geode] +When it comes to Spring's support, whether you are developing with Open Source Software (OSS) {apache-geode-website}[{geode-name}] or developing for {pivotal-cloudcache-website}[Pivotal Cloud Cache], Spring has you covered. At a strategic-level, this means: -1. From _Open Source Software_ (e.g. Apache Geode) to _Commercial_ (e.g. Pivotal Cloud Cache) +1. From _Open Source Software_ (e.g. {geode-name}) to _Commercial_ (e.g. Pivotal Cloud Cache) 2. From _Non-Managed Environments_ (e.g. Standalone, Externally Managed) to _Managed Environments_ (e.g. Pivotal Platform) 3. With _**little**_ to _**no code or configuration**_ changes necessary. It just works! You may also migrate your Spring Boot applications away from Pivotal Platform using the commercial software offering, -Pivotal Cloud Cache, and switch back to Open Source Apache Geode running in a standalone, externally managed environment. +Pivotal Cloud Cache, and switch back to Open Source {geode-name} running in a standalone, externally managed environment. SBDG will never lock you in! It is, and always will be, your choice! -Technically, this means to go from Apache Geode to Pivotal Cloud Cache (PCC), you must change 2 things. +Technically, this means to go from {geode-name} to Pivotal Cloud Cache (PCC), you must change 2 things. First, you must switch the dependency from `spring-geode-starter` to `spring-gemfire-starter`: -.Maven POM with Spring Boot for Apache Geode +.Maven POM with Spring Boot for {geode-name} [source,xml] [subs="verbatim,attributes"] ---- @@ -111,7 +114,7 @@ First, you must switch the dependency from `spring-geode-starter` to `spring-gem ---- -.Gradle build file with Spring Boot for Apache Geode +.Gradle build file with Spring Boot for {geode-name} [source,groovy] [subs="verbatim,attributes"] ---- @@ -122,7 +125,7 @@ dependencies { To: -.Maven POM with Spring Boot for Pivotal GemFire +.Maven POM with Spring Boot for {gemfire-name} [source,xml] [subs="verbatim,attributes"] ---- @@ -133,7 +136,7 @@ To: ---- -.Gradle build file with Spring Boot for Pivotal GemFire +.Gradle build file with Spring Boot for {gemfire-name} [source,groovy] [subs="verbatim,attributes"] ---- @@ -142,10 +145,10 @@ dependencies { } ---- -Second, to obtain the commercial Pivotal Cloud Cache (PCC) or Pivotal GemFire bits, you must declare the appropriate -repository declaration in your Maven POM or Gradle build file: +Second, to obtain the commercial Pivotal Cloud Cache (PCC) or {gemfire-name} bits, you must declare +the appropriate repository declaration in your Maven POM or Gradle build file: -.Maven Repository definition to acquire PCC or Pivotal GemFire bits +.Maven Repository definition to acquire PCC or {gemfire-name} bits [source,xml] ---- @@ -157,7 +160,7 @@ repository declaration in your Maven POM or Gradle build file: ---- -.Gradle Repository definition to acquire PCC or Pivotal GemFire bits +.Gradle Repository definition to acquire PCC or {gemfire-name} bits [source,groovy] ---- repositories { @@ -188,9 +191,9 @@ and password to configure access to the server in your Maven settings (i.e. ~/.m ---- -TIP: For more details on acquiring the Pivotal Cloud Cache (PCC) or Pivotal GemFire bits, see Pivotal GemFire's +TIP: For more details on acquiring the Pivotal Cloud Cache (PCC) or {gemfire-name} bits, see {gemfire-name}'s https://gemfire.docs.pivotal.io/{pivotal-gemfire-version}/gemfire/getting_started/installation/obtain_gemfire_maven.html[documentation]. -When using the `spring-gemfire-starter`, you do not need to declare the Pivotal GemFire dependencies noted in +When using the `spring-gemfire-starter`, you do not need to declare the {gemfire-name} dependencies noted in the documentation. The `spring-gemfire-starter` does that for you! You only need to declare the repository and configure your settings. @@ -200,7 +203,7 @@ Done! It should just work without any code or configuration changes and if this is not the case, for whatever reason, then we will work to correct it, short of any feature differences between Pivotal Cloud Cache (PCC) that cannot be accomplished -with Apache Geode itself, of course. +with {geode-name} itself, of course. Spring Boot's _auto-configuration_ and _convention over configuration_ approach tries to determine the runtime environment in order to handle infrastructure logistics so you do not have to. This is true inside or outside @@ -208,29 +211,29 @@ of a managed environment so that we can provide users with a consistent and reli and issues that arise by switching environments in the first place. Switching environments is especially common as you migrate your Spring Boot applications from DEV to TEST, followed by STAGING, and finally, to PRODUCTION. -Of course, it will nearly always be easier to "run" Apache Geode as a "managed" service inside Pivotal Platform (PCF) -using Pivotal Cloud Cache (PCC) than it will be to manage an externally run Apache Geode cluster, especially if your +Of course, it will nearly always be easier to "run" {geode-name} as a "managed" service inside Pivotal Platform (PCF) +using Pivotal Cloud Cache (PCC) than it will be to manage an externally run {geode-name} cluster, especially if your Use Cases require maximum performance and high availability. We highly recommend this approach when and where possible, but it is still your choice. [[geode-cluster-configuration-bootstrapping]] -=== Running an Apache Geode or Pivotal GemFire cluster using Spring Boot from your IDE +=== Running an {geode-name} cluster using Spring Boot from your IDE -As described in <>, it is possible to configure and run a small Apache Geode -or Pivotal GemFire cluster from inside your IDE using Spring Boot. This is extremely helpful during development -since it allows you to manually spin up, test and debug your applications quickly and easily. +As described in <>, it is possible to configure and run a small {geode-name} cluster +from inside your IDE using Spring Boot. This is extremely helpful during development since it allows you to manually +spin up, test and debug your applications quickly and easily. -Spring Boot for Apache Geode/Pivotal GemFire includes such a class: +Spring Boot for {geode-name} includes such a class: -.Spring Boot application class used to configure and bootstrap an Apache Geode/Pivotal GemFire server +.Spring Boot application class used to configure and bootstrap an {geode-name} server [source,java] ---- include::{docs-src-dir}/org/springframework/geode/docs/example/app/server/SpringBootApacheGeodeCacheServerApplication.java[tags=class] ---- -This class is a proper Spring Boot application that can be used to configure and bootstrap multiple Apache Geode -or Pivotal GemFire servers and joining them together to form a small cluster simply by modifying -the runtime configuration of this class ever so slightly. +This class is a proper Spring Boot application that can be used to configure and bootstrap multiple {geode-name} servers +and join them together to form a small cluster simply by modifying the runtime configuration of this class ever so +slightly. Initially you will want to start a single, primary server with the embedded Locator and Manager service. @@ -241,7 +244,7 @@ route data requests directly to the server hosting the data (a.k.a. single-hop a is partitioned/sharded across servers in the cluster. Locator Pools include support for load balancing connections and handling automatic fail-over in the event of failed connections, among other things. -The Manager service enables you to connect to this server using _Gfsh_ (the Apache Geode and Pivotal GemFire +The Manager service enables you to connect to this server using _Gfsh_ (the {geode-name} {apache-geode-docs}/tools_modules/gfsh/chapter_overview.html[shell tool]). To start our primary server, create a run configuration in your IDE for the `SpringBootApacheGeodeCacheServerApplication` @@ -421,9 +424,8 @@ Client Connections : 0 Now, let's start some additional servers to scale-out our cluster. -To do so, you simply need to vary the name of the members we will add to our cluster as peers. Apache Geode -and Pivotal GemFire require that the members in a cluster be named and the names of each member in the cluster -be unique. +To do so, you simply need to vary the name of the members we will add to our cluster as peers. {geode-name} requires +that the members in a cluster be named and the names of each member in the cluster be unique. Additionally, since we are running multiple instances of our `SpringBootApacheGeodeCacheServerApplication` class, which also embeds a `CacheServer` instance enabling cache clients to connect, we need to be careful to vary our @@ -548,47 +550,45 @@ Running : true Client Connections : 0 ---- -Congratulations! You just started a small Apache Geode/Pivotal GemFire cluster, with 3 members, using Spring Boot -from inside your IDE. +Congratulations! You just started a small {geode-name} cluster, with 3 members, using Spring Boot from inside your IDE. -It is pretty simple to build and run a Spring Boot, Apache Geode/Pivotal GemFire, `ClientCache` application -that connects to this cluster. Simply include and use Spring Boot for Apache Geode/Pivotal GemFire, ;-). +It is pretty simple to build and run a Spring Boot, {geode-name}, `ClientCache` application that connects to +this cluster. Simply include and use Spring Boot for {geode-name}, ;-). [[geode-testing]] === Testing -https://github.com/spring-projects/spring-test-data-geode[Spring Test for Apache Geode & Pivotal GemFire] is a new, -soon to be released and upcoming project to help developers write both _Unit_ and _Integration Tests_ -when using either Apache Geode or Pivotal GemFire in a Spring context. +https://github.com/spring-projects/spring-test-data-geode[Spring Test for {geode-name}] is a new, soon to be released +and upcoming project to help developers write both _Unit_ and _Integration Tests_ when using {geode-name} +in a Spring context. In fact, the entire {github-url}/tree/master/spring-geode-autoconfigure/src/test/java/org/springframework/geode/boot/autoconfigure[test suite] -in Spring Boot for Apache Geode & Pivotal GemFire is based on this project. +in Spring Boot for {geode-name} is based on this project. -All Spring projects integrating with either Apache Geode or Pivotal GemFire will use this new test framework for all -their testing needs, making this new test framework for Apache Geode and Pivotal GemFire a proven and reliable solution -for all your Apache Geode/Pivotal GemFire application testing needs when using Spring as well. +All Spring projects integrating with either {geode-name} will use this new test framework for all their testing needs, +making this new test framework for {geode-name} a proven and reliable solution for all your {geode-name} application +testing needs when using Spring as well. Later on, this reference guide will include and dedicate an entire chapter on testing. [[geode-examples]] === Examples -The definitive source of truth on how to best use Spring Boot for Apache Geode & Pivotal GemFire (or Pivotal Cloud Cache -(PCC)) is to refer to the <>. +The definitive source of truth on how to best use Spring Boot for {geode-name} is to refer to the <>. Refer to the Pivotal Cloud Cache (PCC), https://github.com/pivotal-cf/PCC-Sample-App-PizzaStore[Pizza Store], -Spring Boot application for an example of how to use Spring Boot for Pivotal GemFire (SBDG) in a `ClientCache` +Spring Boot application for an example of how to use Spring Boot for {gemfire-name} (SBDG) in a `ClientCache` application interfacing with PCC. Additionally, you may refer to the https://github.com/jxblum/temperature-service[Temperature Service], Spring Boot application, which implements a Temperature Sensor and Monitoring, Internet of Things (IOT) example. The example uses -SBDG to showcase Apache Geode CQ, Function Implementations/Executions and positions Apache Geode as a _caching provider_ +SBDG to showcase {geode-name} CQ, Function Implementations/Executions and positions {geode-name} as a _caching provider_ in Spring's Cache Abstraction. It is a working, sophisticated and complete example, and is highly recommended as a good starting point for real-world use cases. You may also refer to the https://github.com/jxblum/contacts-application/tree/master/boot-example[boot-example] -from the _Contact Application_ Reference Implementation (RI) for Spring Data for Apache Geode & Pivotal GemFire -(SDG) as yet another example. +from the _Contact Application_ Reference Implementation (RI) for Spring Data for {geode-name} (SDG) +as yet another example. [[references]] === References @@ -596,8 +596,8 @@ from the _Contact Application_ Reference Implementation (RI) for Spring Data for 1. Spring Framework {spring-framework-docs}[Reference Guide] | {spring-framework-javadoc}[Javadoc] 2. Spring Boot {spring-boot-docs-html}[Reference Guide] | {spring-boot-javadoc}[Javadoc] 3. Spring Data Commons {spring-data-commons-docs-html}[Reference Guide] | {spring-data-commons-javadoc}[Javadoc] -4. Spring Data for Apache Geode {spring-data-geode-docs-html}[Reference Guide] | {spring-data-geode-javadoc}[Javadoc] -5. Spring Session for Apache Geode {spring-session-data-gemfire-docs}[Reference Guide] | {spring-session-data-gemfire-javadoc}[Javadoc] -6. Spring Test for Apache Geode {spring-test-data-gemfire-website}[README] -7. Apache Geode {apache-geode-docs}[User Guide] | {apache-geode-javadoc}[Javadoc] -8. Pivotal GemFire {pivotal-gemfire-docs}[User Guide] | {pivotal-gemfire-javadoc}[Javadoc] +4. Spring Data for {geode-name} {spring-data-geode-docs-html}[Reference Guide] | {spring-data-geode-javadoc}[Javadoc] +5. Spring Session for {geode-name} {spring-session-data-gemfire-docs}[Reference Guide] | {spring-session-data-gemfire-javadoc}[Javadoc] +6. Spring Test for {geode-name} {spring-test-data-gemfire-website}[README] +7. {geode-name} {apache-geode-docs}[User Guide] | {apache-geode-javadoc}[Javadoc] +8. {gemfire-name} {pivotal-gemfire-docs}[User Guide] | {pivotal-gemfire-javadoc}[Javadoc] diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/clientcache-applications.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/clientcache-applications.adoc index f8e47f66..aea6515f 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/clientcache-applications.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/clientcache-applications.adoc @@ -1,17 +1,17 @@ [[geode-clientcache-applications]] == Building ClientCache Applications -The first, opinionated option provided to you by Spring Boot for Apache Geode & Pivotal GemFire (SBDG) out-of-the-box is -a {apache-geode-javadoc}/org/apache/geode/cache/client/ClientCache.html[ClientCache] instance, simply by declaring -either Spring Boot for Apache Geode or Spring Boot for Pivotal GemFire on your application classpath. +The first, opinionated option provided to you by Spring Boot for Apache Geode (SBDG) out-of-the-box is a +{apache-geode-javadoc}/org/apache/geode/cache/client/ClientCache.html[ClientCache] instance, simply by declaring +Spring Boot for Apache Geode (SBDG) on your application classpath. -It is assumed that most application developers using Spring Boot to build applications backed by either Apache Geode -or Pivotal GemFire will be building cache client applications deployed in an Apache Geode or Pivotal GemFire +It is assumed that most application developers using Spring Boot to build applications backed by Apache Geode will be +building cache client applications deployed in an Apache Geode {apache-geode-docs}/topologies_and_comm/cs_configuration/chapter_overview.html[Client/Server topology]. A client/server topology is the most common and traditional architecture employed by enterprise applications. -For example, you can begin building a Spring Boot, Apache Geode or Pivotal GemFire, `ClientCache` application -with either the `spring-geode-starter` or `spring-gemfire-starter` on your application's classpath: +For example, you can begin building a Spring Boot, Apache Geode `ClientCache` application with either +the `spring-geode-starter` or `spring-gemfire-starter` on your application's classpath: .Spring Boot for Apache Geode on the application classpath [source,xml] @@ -37,12 +37,12 @@ public class SpringBootApacheGeodeClientCacheApplication { } ---- -Your application now has a `ClientCache` instance, which is able to connect to an Apache Geode or Pivotal GemFire server -running on `localhost`, listening on the default `CacheServer` port, `40404`. +Your application now has a `ClientCache` instance, which is able to connect to an Apache Geode server running on +`localhost`, listening on the default `CacheServer` port, `40404`. -By default, an Apache Geode or Pivotal GemFire server (i.e. `CacheServer`) must be running in order to use -the `ClientCache` instance. However, it is perfectly valid to create a `ClientCache` instance and perform -data access operations using `LOCAL` Regions. This is very useful during development. +By default, an Apache Geode server (i.e. `CacheServer`) must be running in order to use the `ClientCache` instance. +However, it is perfectly valid to create a `ClientCache` instance and perform data access operations using `LOCAL` +Regions. This is very useful during development. TIP: To develop with `LOCAL` Regions, you only need to define your cache Regions with the {apache-geode-javadoc}/org/apache/geode/cache/client/ClientRegionShortcut.html#LOCAL[`ClientRegionShortcut.LOCAL`] @@ -53,7 +53,7 @@ environment, you simply change the data management policy of the client Region f or even a `CACHING_PROXY`, data management policy which will cause the data to be sent/received to and from 1 or more servers, respectively. -TIP: Compare and contrast the above configuration with Spring Data for Apache Geode/Pivotal GemFire's +TIP: Compare and contrast the above configuration with Spring Data for Apache Geode's {spring-data-geode-docs-html}/#bootstrap-annotation-config-geode-applications[approach]. It is uncommon to ever need a direct reference to the `ClientCache` instance provided by SBDG injected into your @@ -103,12 +103,12 @@ It is the 2nd part, "_get out of the way quickly as requirements start to diverg that we refer to here. If your application requirements demand you use Spring Boot to configure and bootstrap an embedded, peer `Cache` -Apache Geode or Pivotal GemFire application, then simply declare your intention with either SDG's +Apache Geode application, then simply declare your intention with either SDG's {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/PeerCacheApplication.html[`@PeerCacheApplication`] annotation, or alternatively, if you need to enable connections from `ClientCache` apps as well, use the SDG {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/CacheServerApplication.html[`@CacheServerApplication`] annotation: -.Spring Boot, Apache Geode/Pivotal GemFire CacheServer Application +.Spring Boot, Apache Geode CacheServer Application [source,java] ---- @SpringBootApplication @@ -121,8 +121,8 @@ public class SpringBootApacheGeodeCacheServerApplication { } ---- -TIP: An Apache Geode/Pivotal GemFire "server" is not necessarily a "`CacheServer`" capable of serving cache clients. -It is merely a peer member node in a GemFire/Geode cluster (a.k.a. distributed system) that stores and manages data. +TIP: An Apache Geode "server" is not necessarily a "`CacheServer`" capable of serving cache clients. It is merely a +peer member node in a GemFire/Geode cluster (a.k.a. distributed system) that stores and manages data. By explicitly declaring the `@CacheServerApplication` annotation, you are telling Spring Boot that you do not want the default, `ClientCache` instance, but rather an embedded, peer `Cache` instance with a `CacheServer` component, @@ -133,7 +133,7 @@ to "locate" servers in a cluster, as well as an embedded _Manager_, which allows to be managed and monitored using {apache-geode-docs}/tools_modules/gfsh/chapter_overview.html[_Gfsh_], GemFire/Geode's shell tool: -.Spring Boot, Apache Geode/Pivotal GemFire CacheServer Application with _Locator_ and _Manager_ services enabled +.Spring Boot, Apache Geode `CacheServer` Application with _Locator_ and _Manager_ services enabled [source,java] ---- @SpringBootApplication @@ -197,9 +197,9 @@ Client Connections : 0 ---- You can even start additional servers in _Gfsh_, which will connect to your Spring Boot configured and bootstrapped -Apache Geode or Pivotal GemFire `CacheServer` application. These additional servers started in _Gfsh_ know about -the Spring Boot, GemFire/Geode server because of the embedded _Locator_ service, which is running on `localhost`, -listening on the default _Locator_ port, `10334`: +Apache Geode `CacheServer` application. These additional servers started in _Gfsh_ know about the Spring Boot, +Apache Geode server because of the embedded _Locator_ service, which is running on `localhost`, listening on +the default _Locator_ port, `10334`: [source,text] ---- @@ -268,7 +268,7 @@ GfshServer | 10.0.0.121(GfshServer:30270):1025 Then, modify the `SpringBootApacheGeodeCacheServerApplication` class to connect to the existing cluster, like so: -.Spring Boot, Apache Geode/Pivotal GemFire CacheServer Application with _Locator_ and _Manager_ services enabled +.Spring Boot, Apache Geode `CacheServer` Application with _Locator_ and _Manager_ services enabled [source,java] ---- @SpringBootApplication @@ -317,8 +317,8 @@ Running : true Client Connections : 0 ---- -In both scenarios, the Spring Boot configured and bootstrapped Apache Geode (or Pivotal GemFire) server -and the _Gfsh_ _Locator_ and _Server_ formed a cluster. +In both scenarios, the Spring Boot configured and bootstrapped Apache Geode server and the _Gfsh_ _Locator_ and _Server_ +formed a cluster. While you can use either approach and Spring does not care, it is far more convenient to use Spring Boot and your IDE to form a small cluster while developing. By leveraging Spring profiles, it is far simpler and much faster to @@ -342,10 +342,10 @@ TIP: See the Appendix, <> for more de In addition to `ClientCache`, `CacheServer` and peer `Cache` applications, SDG, and by extension SBDG, now supports Locator-based, Spring Boot applications. -An Apache Geode or Pivotal GemFire Locator is a location-based service, or alternatively and more typically, -a standalone process enabling clients to "locate" a cluster of Apache Geode/Pivotal GemFire servers to manage data. -Many cache clients can connect to the same cluster in order to share data. Running multiple clients is common in a -Microservices architecture where you need to scale-up the number of app instances to satisfy the demand. +An Apache Geode Locator is a location-based service, or alternatively and more typically, a standalone process enabling +clients to "locate" a cluster of Apache Geode servers to manage data. Many cache clients can connect to the same cluster +in order to share data. Running multiple clients is common in a Microservices architecture where you need to scale-up +the number of app instances to satisfy the demand. A Locator is also used by joining members of an existing cluster to scale-out and increase capacity of the logically pooled system resources (i.e. Memory, CPU and Disk). A Locator maintains metadata that is sent to the clients to @@ -398,8 +398,8 @@ class SpringBootApacheGeodeLocatorApplication { Instead of using the `@EnableLocator` annotation, you now use the `@LocatorApplication` annotation. The `@LocatorApplication` annotation works in the same way as the `@PeerCacheApplication` and `@CacheServerApplication` -annotations, bootstrapping a Apache Geode or Pivotal GemFire process, overriding the default `ClientCache` instance -provided by SBDG out-of-the-box. +annotations, bootstrapping a Apache Geode process, overriding the default `ClientCache` instance provided by SBDG +out-of-the-box. NOTE: If your `@SpringBootApplication` class is annotated with `@LocatorApplication`, then it can only be a `Locator` and not a `ClientCache`, `CacheServer` or peer `Cache` application. If you need the application to function as a @@ -420,14 +420,14 @@ include::{docs-src-dir}/org/springframework/geode/docs/example/app/locator/Sprin We also need to vary the configuration for each Locator app instance. -Apache Geode and Pivotal GemFire requires each peer member in the cluster to be uniquely named. We can set the name -of the Locator by using the `spring.data.gemfire.locator.name` SDG property set as a JVM System Property in your IDE's -Run Configuration Profile for the application main class like so: `-Dspring.data.gemfire.locator.name=SpringLocatorOne`. -We name the second Locator app instance, "_SpringLocatorTwo_". +Apache Geode requires each peer member in the cluster to be uniquely named. We can set the name of the Locator by using +the `spring.data.gemfire.locator.name` SDG property set as a JVM System Property in your IDE's Run Configuration Profile +for the application main class like so: `-Dspring.data.gemfire.locator.name=SpringLocatorOne`. We name the second +Locator app instance, "_SpringLocatorTwo_". Additionally, we must vary the port numbers that the Locators use to listen for connections. By default, -an Apache Geode or Pivotal GemFire Locator listens on port `10334`. We can set the Locator port using the -`spring.data.gemfire.locator.port` SDG property. +an Apache Geode Locator listens on port `10334`. We can set the Locator port using +the `spring.data.gemfire.locator.port` SDG property. For our first Locator app instance (i.e. "_SpringLocatorOne_"), we also enable the "_manager_" Profile so that we can connect to the Locator using _Gfsh_. @@ -616,17 +616,17 @@ GfshServer | 10.99.199.24(GfshServer:30295):41004 ---- You must be careful to vary the ports and name your peer members appropriately. With Spring, and Spring Boot -for Apache Geode and Pivotal GemFire (SBDG) in particular, it really is that easy! +for Apache Geode (SBDG) in particular, it really is that easy! [[geode-manager-applications]] === Building Manager Applications As discussed in the previous sections above, it is possible to enable a Spring Boot configured and bootstrapped -Apache Geode or Pivotal GemFire peer member node in the cluster to function as a _Manager_. +Apache Geode peer member node in the cluster to function as a _Manager_. -An Apache Geode or Pivotal GemFire _Manager_ is a peer member node in the cluster running the Management Service, -allowing the cluster to be managed and monitored using JMX based tools, like _Gfsh_, _JConsole_ or _JVisualVM_, -for instance. Any tool that uses the JMX API can connect to and manage the GemFire/Geode cluster for whatever purpose. +An Apache Geode _Manager_ is a peer member node in the cluster running the Management Service, allowing the cluster +to be managed and monitored using JMX based tools, like _Gfsh_, _JConsole_ or _JVisualVM_, for instance. Any tool +that uses the JMX API can connect to and manage the GemFire/Geode cluster for whatever purpose. The cluster may have more than 1 _Manager_ for redundancy. Only server-side, peer member nodes in the cluster may function as a _Manager_. Therefore, a `ClientCache` application cannot be a _Manager_. @@ -683,8 +683,8 @@ TIP: See the `@EnableManager` annotation for additional configuration options. As of Apache Geode 1.11.0, you must now include additional Geode dependencies on your Spring Boot application classpath -to make your application a proper Apache Geode/Pivotal GemFire _Manager_ in the cluster, particularly if you are also -enabling the embedded HTTP service in the _Manager_. +to make your application a proper Apache Geode _Manager_ in the cluster, particularly if you are also enabling +the embedded HTTP service in the _Manager_. The required dependencies are: diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/cloudfoundry.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/cloudfoundry.adoc index 5868d222..14879042 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/cloudfoundry.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/cloudfoundry.adoc @@ -6,7 +6,7 @@ In most cases, when you "_push_" (i.e. "_deploy_") your Spring Boot applications you will bind your app to 1 or more instances of the Pivotal Cloud Cache (PCC) service. In a nutshell, {pivotal-cloudcache-website}[Pivotal Cloud Cache] is a managed version of -{pivotal-gemfire-website}[Pivotal GemFire] running in {pivotal-cloudfoundry-website}[Pivotal CloudFoundry]. +{pivotal-gemfire-website}[VMware Tanzu GemFire] running in {pivotal-cloudfoundry-website}[Pivotal CloudFoundry]. When running in or across cloud environments (e.g. AWS, Azure, GCP or PWS), PCC with PCF offers several advantages over trying to run and manage your own standalone Apache Geode or Pivotal GemFir clusters. It handles many of the infrastructure-related, operational concerns so you do not have to. @@ -34,12 +34,12 @@ the `@EnableClusterConfiguration` annotation: ---- @SpringBootApplication @EnableClusterConfiguration(useHttp = true) -class SpringBootApacheGeodeClientCacheApplication { ... } +class SpringBootApacheGeodeClientCacheApplication { } ---- With `@EnableClusterConfiguration`, Region and OQL Index configuration metadata defined on the client can be sent to -servers in the PCC cluster. Apache Geode and Pivotal GemFire requires matching Regions by name on both the client -and servers in order for clients to send and receive data to and from the cluster. +servers in the PCC cluster. Apache Geode requires matching Regions by name on both the client and servers in order for +clients to send and receive data to and from the cluster. For example, when you declare the Region where an application entity will be persisted using the `@Region` mapping annotation and additionally declare the `@EnableEntityDefinedRegions` annotation on the main `@SpringBootApplication` @@ -82,7 +82,6 @@ Configuration metadata for the PCC service instance might appear as follows: "password": "*****", "roles": [ "developer" ], "username": "developer_user" - }, }, { "password": "*****", "roles": [ "read-only-user" ], @@ -97,7 +96,6 @@ Configuration metadata for the PCC service instance might appear as follows: } } }, - ... "name": "jblum-pcc", "plan": "small", "tags": [ "gemfire", "cloudcache", "database", "pivotal" ] @@ -122,9 +120,9 @@ TIP: The `spring.data.gemfire.security.username` property corresponds directly t See the {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableSecurity.html#securityUsername--[Javadoc] for more details. -The `spring.data.gemfire.security.username` property is the same property used by Spring Data for Apache Geode -and Pivotal GemFire (SDG) to configure the runtime user of your Spring Data application when connecting to either -an externally managed Apache Geode or Pivotal GemFire cluster. +The `spring.data.gemfire.security.username` property is the same property used by Spring Data for Apache Geode (SDG) +to configure the runtime user of your Spring Data application when connecting to either an externally managed +Apache Geode cluster. In this case, SBDG simply uses the configured username to lookup the authentication credentials of the user to set the username and password used by the Spring Boot, `ClientCache` app when connecting to PCC while running in PCF. @@ -164,9 +162,9 @@ will not be extracted from the environment. It is possible to provision multiple instances of the Pivotal Cloud Cache service in your Pivotal CloudFoundry environment. You can then bind multiple PCC service instances to your Spring Boot app. -However, Spring Boot for Apache Geode & Pivotal GemFire (SBDG) will only auto-configure 1 PCC service instance for your -Spring Boot application. This does not mean it is not possible to use multiple PCC service instances with your -Spring Boot app, just that SBDG only "_auto-configures_" 1 service instance for you. +However, Spring Boot for Apache Geode (SBDG) will only auto-configure 1 PCC service instance for your Spring Boot +application. This does not mean it is not possible to use multiple PCC service instances with your Spring Boot app, +just that SBDG only "_auto-configures_" 1 service instance for you. You must select which PCC service instance your Spring Boot app will auto-configure for you automatically when you have multiple instances and want to target a specific PCC service instance to use. @@ -211,7 +209,7 @@ The configuration would be similar to the following: @EnablePool(name = "PccN") }) class PccConfiguration { - ... + // ... } ---- @@ -267,11 +265,10 @@ as discussed <>. === Hybrid Pivotal CloudFoundry & Apache Geode Spring Boot Applications Sometimes, it is desirable to deploy (i.e. "_push_") and run your Spring Boot applications in Pivotal CloudFoundry, -but still connect your Spring Boot applications to an externally managed, standalone Apache Geode or Pivotal GemFire -cluster. +but still connect your Spring Boot applications to an externally managed, standalone Apache Geode cluster. -Spring Boot for Apache Geode & Pivotal GemFire (SBDG) makes this a non-event and honors its "_little to no code -or configuration changes necessary_" goal, regardless of your runtime choice, "_it should just work!_" +Spring Boot for Apache Geode (SBDG) makes this a non-event and honors its "_little to no code or configuration changes +necessary_" goal, regardless of your runtime choice, "_it should just work!_" To help guide you through this process, we will cover the following topics: @@ -294,7 +291,7 @@ can be bound and used by your Spring Boot application to accomplish its tasks. However, PCF Dev lacks the Pivotal Cloud Cache (PCC) service that is available in PCF. This is actually ideal for this little exercise since we are trying to build and run Spring Boot applications in a PCF environment -but connect to an externally managed, standalone Apache Geode or Pivotal GemFire cluster. +but connect to an externally managed, standalone Apache Geode cluster. As a prerequisite, you will need to follow the steps outlined in the https://pivotal.io/platform/pcf-tutorials/getting-started-with-pivotal-cloud-foundry-dev/introduction[tutorial] @@ -486,8 +483,8 @@ Now that we have PCF Dev and a small Apache Geode cluster up and running, it is to the external, standalone Apache Geode cluster that we started in <>. As mentioned, PCF Dev offers the MySQL, Redis and RabbitMQ services out-of-the-box. However, to use Apache Geode -(or Pivotal GemFire) in the same capacity as you would Pivotal Cloud Cache when running in a production-grade, -PCF environment, you need to create a User-Provided Service for the standalone Apache Geode cluster. +in the same capacity as you would Pivotal Cloud Cache when running in a production-grade, PCF environment, you need +to create a User-Provided Service for the standalone Apache Geode cluster. To do so, execute the following `cf` CLI command: @@ -757,8 +754,8 @@ Rows : 1 There you have it! -The ability to deploy Spring Boot, Apache Geode or Pivotal GemFire `ClientCache` applications to Pivotal CloudFoundry, -yet connect your app to a externally managed, standalone Apache Geode or Pivotal GemFire cluster. +The ability to deploy Spring Boot, Apache Geode `ClientCache` applications to Pivotal CloudFoundry, yet connect your app +to a externally managed, standalone Apache Geode cluster. Indeed, this is will be a useful arrangement and stepping stone for many users as they begin their journey towards a Cloud-Native platform like Pivotal CloudFoundry (PCF) and using services like Pivotal Cloud Cache (PCC). diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/configuration-annotations.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/configuration-annotations.adoc index 9306affb..35fc1720 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/configuration-annotations.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/configuration-annotations.adoc @@ -1,31 +1,30 @@ [[geode-auto-configuration-annotations]] == Auto-configuration vs. Annotation-based configuration -The question most often asked is, "_What Spring Data for Apache Geode/Pivotal GemFire annotations can I use, -or must I use, when developing Apache Geode or Pivotal GemFire applications with Spring Boot?_" +The question most often asked is, "_What Spring Data for Apache Geode annotations can I use, or must I use, +when developing Apache Geode applications with Spring Boot?_" This section will answer this question and more. -Readers should refer to the complimentary sample, link:guides/boot-configuration.html[Spring Boot Auto-configuration for Apache Geode & Pivotal GemFire], -which showcases the _auto-configuration_ provided by Spring Boot for Apache Geode/Pivotal GemFire in action. +Readers should refer to the complimentary sample, link:guides/boot-configuration.html[Spring Boot Auto-configuration for Apache Geode], +which showcases the _auto-configuration_ provided by Spring Boot for Apache Geode in action. [[geode-autoconfiguration-annotations-background]] === Background To help answer this question, we must start by reviewing the complete collection of available -Spring Data for Apache Geode/Pivotal GemFire (SDG) annotations. These annotations are provided in the +Spring Data for Apache Geode (SDG) annotations. These annotations are provided in the {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/package-summary.html[org.springframework.data.gemfire.config.annotation] package. Most of the pertinent annotations begin with `@Enable...`, except for the base annotations: `@ClientCacheApplication`, `@PeerCacheApplication` and `@CacheServerApplication`. -By extension, Spring Boot for Apache Geode/Pivotal GemFire (SBDG) builds on SDG's Annotation-based configuration model -to implement _auto-configuration_ and apply Spring Boot's core concepts, like "_convention over configuration_", -enabling GemFire/Geode applications to be built with Spring Boot reliably, quickly and easily. +By extension, Spring Boot for Apache Geode (SBDG) builds on SDG's Annotation-based configuration model to implement +_auto-configuration_ and apply Spring Boot's core concepts, like "_convention over configuration_", enabling Apache +Geode applications to be built with Spring Boot reliably, quickly and easily. SDG provides this Annotation-based configuration model to, first and foremost, give application developers "_choice_" -when building Spring applications using either Apache Geode or Pivotal GemFire. SDG makes no assumptions about what -application developers are trying to do and fails fast anytime the configuration is ambiguous, giving users immediate -feedback. +when building Spring applications using Apache Geode. SDG makes no assumptions about what application developers are +trying to do and fails fast anytime the configuration is ambiguous, giving users immediate feedback. Second, SDG's Annotations were meant to get application developers up and running quickly and reliably with ease. SDG accomplishes this by applying sensible defaults so application developers do not need to know, or even have to learn, @@ -84,8 +83,8 @@ By default, SBDG provides you with a `ClientCache` instance. Technically, SBDG an auto-configuration class with `@ClientCacheApplication`, internally. It is by convention that we assume most application developers' will be developing Spring Boot applications -using Apache Geode or Pivotal GemFire as "client" applications in GemFire/Geode's client/server topology. This is -especially true as users migrate their applications to a managed environment, such as Pivotal CloudFoundry (PCF) +using Apache Geode as "client" applications in GemFire/Geode's client/server topology. This is especially true +as users migrate their applications to a managed environment, such as Pivotal CloudFoundry (PCF) using Pivotal Cloud Cache (PCC). Still, users are free to "override" the default settings and declare their Spring applications to be actual peer `Cache` @@ -97,7 +96,7 @@ For example: ---- @SpringBootApplication @CacheServerApplication -class MySpringBootPeerCacheServerApplication { ... } +class MySpringBootPeerCacheServerApplication { } ---- By declaring the `@CacheServerApplication` annotation, you effectively override the SBDG default. Therefore, SBDG @@ -220,7 +219,7 @@ You can do that by defining each Region explicitly, or more conveniently, you ca ---- @SpringBootApplication @EnableCachingDefinedRegions -class Application { ... } +class Application { } ---- `@EnableCachingDefinedRegions` is optional, provided for convenience, and complimentary to caching when used @@ -275,7 +274,7 @@ class GemFireFunctions { @GemfireFunction Object exampleFunction(Object arg) { - ... + // ... } } ---- diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/configuration-declarative.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/configuration-declarative.adoc index 406dd466..9257941c 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/configuration-declarative.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/configuration-declarative.adoc @@ -36,11 +36,11 @@ Now, that we explained the motivation behind this chapter, let's outline what we * Refer you to the SDG _Annotations_ covered by SBDG's _Auto-configuration_ * List all SDG _Annotations_ not covered by SBDG's _Auto-configuration_ * Cover the SBDG, SSDG and SDG _Annotations_ that must be declared explicitly and that provide the most value and productivity -when getting started using either Apache Geode or Pivotal GemFire in Spring [Boot] applications. +when getting started using Apache Geode in Spring [Boot] applications. -NOTE: SDG refers to {spring-data-geode-website}[Spring Data for Apache Geode & Pivotal GemFire]. SSDG refers to -{spring-session-data-gemfire-website}[Spring Session for Apache Geode & Pivotal GemFire] and SBDG refers to -_Spring Boot for Apache Geode & Pivotal GemFire_, this project. +NOTE: SDG refers to {spring-data-geode-website}[Spring Data for Apache Geode]. SSDG refers to +{spring-session-data-gemfire-website}[Spring Session for Apache Geode] and SBDG refers to +_Spring Boot for Apache Geode_, this project. TIP: The list of SDG _Annotations_ covered by SBDG's _Auto-configuration_ is discussed in detail in the <>, in the section, <>. @@ -134,7 +134,7 @@ Still, all of these _Annotations_ are available for the application developer to === Productivity Annotations This section calls out the _Annotations_ we believe to be most beneficial for your application development purposes -when using either Apache Geode or Pivotal GemFire in Spring Boot applications. +when using Apache Geode in Spring Boot applications. [[geode-configuration-declarative-annotations-productivity-enableclusteraware]] ==== `@EnableClusterAware` (SBDG) @@ -148,14 +148,14 @@ When you annotate your main `@SpringBootApplication` class with `@EnableClusterA ---- @SpringBootApplication @EnableClusterAware -class SpringBootApacheGeodeClientCacheApplication { ... } +class SpringBootApacheGeodeClientCacheApplication { } ---- Your Spring Boot, Apache Geode `ClientCache` application is able to seamlessly switch between client/server and local-only topologies with no code or configuration changes. -When a cluster of Apache Geode or Pivotal GemFire servers is detected, the client application will send and receive data -to and from the cluster. If a cluster is not available, then the client automatically switches to storing data locally +When a cluster of Apache Geode servers is detected, the client application will send and receive data to and from +the cluster. If a cluster is not available, then the client automatically switches to storing data locally on the client using `LOCAL` Regions. Additionally, the `@EnableClusterAware` annotation is meta-annotated with SDG's @@ -228,9 +228,9 @@ For example, given: @Service class CustomerService { - @Cacheable("CustomersByAccountNumber" key="#account.number") + @Cacheable(cacheName = "CustomersByAccountNumber", key="#account.number") Customer findBy(Account account) { - ... + // ... } } ---- @@ -242,7 +242,7 @@ When your main `@SpringBootApplication` class is annotated with `@EnableCachingD ---- @SpringBootApplication @EnableCachingDefineRegions -class SpringBootApacheGeodeClientCacheApplication { ... } +class SpringBootApacheGeodeClientCacheApplication { } ---- Then, SBDG would create a client `PROXY` Region (or `PARTITION_REGION` if your application were a peer member of the @@ -276,7 +276,6 @@ class Customer { @Indexed private String name; - ... } ---- @@ -290,7 +289,7 @@ the main `@SpringBootApplication` class is annotated with `@EnableEntityDefinedR @SpringBootApplication @EnableEntityDefinedRegions(basePackageClasses = Customer.class, clientRegionShortcut = ClientRegionShortcut.CACHING_PROXY) -class SpringBootApacheGeodeClientCacheApplication { ... } +class SpringBootApacheGeodeClientCacheApplication { } ---- Like the `@EnableCachingDefinedRegions` annotation, you can set the client and server Region data management policy @@ -339,7 +338,7 @@ Then, you could configure the `@EnableEntityDefinedRegions` as follows: ---- @SpringBootApplication @EnableEntityDefinedRegions(basePackageClasses = { NonEntity.class, Account.class } ) -class SpringBootApacheGeodeClientCacheApplication { ... } +class SpringBootApacheGeodeClientCacheApplication { } ---- If `Customer`, `Address`, `PhoneNumber` and `Account` were all entity classes properly annotated with `@Region`, then @@ -365,7 +364,7 @@ This is as simple as annotating your main `@SpringBootApplication` class with `@ ---- @SpringBootApplication @EnableClusterDefinedRegions -class SpringBootApacheGeodeClientCacheApplication { ... } +class SpringBootApacheGeodeClientCacheApplication { } ---- Every Region that exists on the cluster of servers will have a corresponding `PROXY` Region defined and created on the @@ -389,8 +388,9 @@ class SomeApplicationComponent { this.serverRegion.put(1, entity); - ... + // ... } +} ---- Of course, SBDG _auto-configures_ a `GemfireTemplate` for the "_ServerRegion_" Region (as described <>), @@ -413,8 +413,9 @@ class SomeApplicationComponent { this.serverRegionTemplate.put(1, entity); - ... + // ... } +} ---- TIP: Refer to the SDG Reference Guide on {spring-data-geode-docs-html}/#bootstrap-annotation-config-region-cluster-defined[Configuring Cluster-defined Regions] @@ -449,7 +450,6 @@ class Customer { @Indexed private String name; - ... } ---- @@ -461,14 +461,14 @@ As a result, when our main `@SpringBootApplication` class is annotated with `@En @SpringBootApplication @EnableEntityDefinedRegions(basePackageClasses = Customer.class) @EnableIndexing -class SpringBootApacheGeodeClientCacheApplication { ... } +class SpringBootApacheGeodeClientCacheApplication { } ---- An Apache Geode OQL Index for the `Customer.name` field will be created thereby making OQL Queries on Customers by name use this Index. -NOTE: Keep in mind that OQL Indexes are not persistent between restarts (i.e. Apache Geode & Pivotal GemFire -maintains Indexes in-memory only). An OQL Index is always rebuilt when the node is restarted. +NOTE: Keep in mind that OQL Indexes are not persistent between restarts (i.e. Apache Geode maintains Indexes +in-memory only). An OQL Index is always rebuilt when the node is restarted. When you combine `@EnableIndexing` with either `@EnableClusterConfiguration` or `@EnableClusterAware`, then the Index definitions will be pushed to the server-side Regions where OQL Queries are generally executed. @@ -479,10 +479,10 @@ for more details. [[geode-configuration-declarative-annotations-productivity-enableexpiration]] ==== `@EnableExpiration` (SDG) -It is often useful to define both _Eviction_ and _Expiration_ policies, particularly with a system like Apache Geode -or Pivotal GemFire, especially given it primarily keeps data in-memory, on the JVM Heap. As you can imagine your data -volume size may far exceed the amount of available JVM Heap memory and/or keeping too much data on the JVM Heap -can cause Garbage Collection (GC) issues. +It is often useful to define both _Eviction_ and _Expiration_ policies, particularly with a system like Apache Geode, +especially given it primarily keeps data in-memory, on the JVM Heap. As you can imagine your data volume size may far +exceed the amount of available JVM Heap memory and/or keeping too much data on the JVM Heap can cause Garbage Collection +(GC) issues. TIP: You can enable off-heap (or main memory usage) capabilities by declaring SDG's `@EnableOffHeap` annotation. Refer to the SDG Reference Guide on {spring-data-geode-docs-html}/#bootstrap-annotation-config-region-off-heap[Configuring Off-Heap Memory] @@ -521,7 +521,6 @@ class Customer { @Indexed private String name; - ... } ---- @@ -535,7 +534,7 @@ with `@EnableExpiration`: ---- @SpringBootApplication @EnableExpiration -class SpringBootApacheGeodeApplication { ... } +class SpringBootApacheGeodeApplication { } ---- NOTE: Technically, this entity class specific Annotation-based Expiration policy is implemented using Apache Geode's @@ -551,23 +550,22 @@ TIP: Refer to the SDG Reference Guide for more details on _Software Testing_ in general, and _Unit Testing_ in particular, are a very important development tasks to ensure the quality of your Spring Boot applications. -Apache Geode and Pivotal GemFire can make testing difficult in some cases, especially when tests have to be written as -_Integration Tests_ in order to assert the correct behavior. This can be very costly and lengthens the feedback cycle. -Fortunately, it is possible to write _Unit Tests_ as well! +Apache Geode can make testing difficult in some cases, especially when tests have to be written as _Integration Tests_ +in order to assert the correct behavior. This can be very costly and lengthens the feedback cycle. Fortunately, it is +possible to write _Unit Tests_ as well! -Spring has your back and once again provides a framework for testing Spring Boot applications using either Apache Geode -or Pivotal GemFire. This is where the {spring-test-data-gemfire-website}[Spring Test for Apache Geode & Pivotal GemFire (STDG)] project -can help, particularly with _Unit Testing_. +Spring has your back and once again provides a framework for testing Spring Boot applications using either Apache Geode. +This is where the {spring-test-data-gemfire-website}[Spring Test for Apache Geode(STDG)] project can help, particularly +with _Unit Testing_. -For example, if you do not care what Apache Geode or Pivotal GemFire would actually do in certain cases and only care -about the "contract", which is what mocking a collaborator is all about, then you could effectively mock Apache Geode -or Pivotal GemFire's objects in order to isolate the "_Subject Under Test_" (SUT) and focus on the interaction(s) -or outcomes you expect to happen. +For example, if you do not care what Apache Geode would actually do in certain cases and only care about the "contract", +which is what mocking a collaborator is all about, then you could effectively mock Apache Geode's objects in order to +isolate the "_Subject Under Test_" (SUT) and focus on the interaction(s) or outcomes you expect to happen. With STDG, you don't have to change a bit of configuration to enable mocks in the _Unit Tests_ for your Spring Boot applications. You simply only need to annotate the test class with `@EnableGemFireMockObjects`, like so: -.Using Mock Apache Geode or Pivotal GemFire objects +.Using Mock Apache Geode objects [source,java] ---- @RunWith(SpringRunner.class) @@ -576,7 +574,7 @@ class MyApplicationTestClass { @Test public void someTestCase() { - ... + // ... } @Configuration @@ -588,8 +586,8 @@ class MyApplicationTestClass { Your Spring Boot configuration of Apache Geode will return mock objects for all Apache Geode objects, such as Regions. -Mocking Apache Geode or Pivotal GemFire objects even works for GemFire/Geode objects created from the productivity -annotations discussed in the previous sections above. +Mocking Apache Geode objects even works for GemFire/Geode objects created from the productivity annotations discussed in +the previous sections above. For example, given the following Spring Boot, Apache Geode `ClientCache` application class: @@ -598,14 +596,14 @@ For example, given the following Spring Boot, Apache Geode `ClientCache` applica ---- @SpringBootApplication @EnableEntityDefinedRegions(basePackageClasses = Customer.class) -class SpringBootApacheGeodeClientCacheApplication { ... } +class SpringBootApacheGeodeClientCacheApplication { } ---- The "_Customers_" Region defined by the `Customer` entity class and created by the `@EnableEntityDefinedRegions` annotation would be a "mock" Region and not an actual Region. You can still inject the Region in your test as before and assert interactions on the Region based on your application workflows: -.Using Mock Apache Geode or Pivotal GemFire objects +.Using Mock Apache Geode objects [source,java] ---- @RunWith(SpringRunner.class) @@ -624,10 +622,10 @@ class MyApplicationTestClass { assertThat(this.customers).containsValue(jonDoe); - ... + // ... } - ... + // ... } ---- diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/configuration-externalized.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/configuration-externalized.adoc index 28e21320..b8786fb6 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/configuration-externalized.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/configuration-externalized.adoc @@ -2,7 +2,7 @@ == Externalized Configuration Like Spring Boot itself (see {spring-boot-docs-html}/boot-features-external-config.html[here]), -Spring Boot for Apache Geode and Pivotal GemFire (SBDG) supports externalized configuration. +Spring Boot for Apache Geode (SBDG) supports externalized configuration. By externalized configuration, we mean configuration metadata stored in a Spring Boot {spring-boot-docs-html}/boot-features-external-config.html#boot-features-external-config-application-property-files[`application.properties` file], @@ -15,14 +15,13 @@ in properties, {spring-boot-docs-html}/boot-features-external-config.html#boot-f properties, and so on. What we are particularly interested in, in this section, is {spring-boot-docs-html}/boot-features-external-config.html#boot-features-external-config-typesafe-configuration-properties[type-safety]. -Like Spring Boot, Spring Boot for Apache Geode & Pivotal GemFire provides a hierarchy of classes used to capture -configuration for several Apache Geode or Pivotal GemFire features in an associated `@ConfigurationProperties` -annotated class. Again, the configuration metadata is specified as well-known, documented properties in 1 or more -Spring Boot `application.properties` files. +Like Spring Boot, Spring Boot for Apache Geode provides a hierarchy of classes used to capture configuration for several +Apache Geode features in an associated `@ConfigurationProperties` annotated class. Again, the configuration metadata is +specified as well-known, documented properties in 1 or more Spring Boot `application.properties` files. For instance, I may have configured my Spring Boot, `ClientCache` application as follows: -.Spring Boot `application.properties` containing Spring Data properties for Apache Geode / Pivotal GemFire +.Spring Boot `application.properties` containing Spring Data properties for Apache Geode [source,properties] ---- # Spring Boot application.properties used to configure Apache Geode @@ -84,14 +83,12 @@ class MyApplicationComponent { // do something with `copyOnRead` } - - ... } ---- Given a handle to {spring-boot-data-geode-javadoc}/org/springframework/geode/boot/autoconfigure/configuration/GemFireProperties.html[`GemFireProperties`], -you can access any of the configuration properties used to configure either Apache Geode or Pivotal GemFire in -a Spring context. You simply only need to autowire an instance of `GemFireProperties` into your application component. +you can access any of the configuration properties used to configure Apache Geode in a Spring context. You simply only +need to autowire an instance of `GemFireProperties` into your application component. A complete reference to the SBDG provided `@ConfigurationProperties` classes and supporting classes is available {spring-boot-data-geode-javadoc}/org/springframework/geode/boot/autoconfigure/configuration/package-frame.html[here]. @@ -99,8 +96,8 @@ A complete reference to the SBDG provided `@ConfigurationProperties` classes and [[geode-configuration-externalized-session]] === Externalized Configuration of Spring Session -The same capability applies to accessing the externalized configuration of Spring Session when using either -Apache Geode or Pivotal GemFire as your (HTTP) Session state caching provider. +The same capability applies to accessing the externalized configuration of Spring Session when using Apache Geode +as your (HTTP) Session state caching provider. In this case, you simply only need to acquire a reference to an instance of the {spring-boot-data-geode-javadoc}/org/springframework/geode/boot/autoconfigure/configuration/SpringSessionProperties.html[`SpringSessionProperties`] @@ -135,7 +132,5 @@ class MyApplicationComponent { // do something with `sessionRegionName` } - - ... } ---- diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/configuration-properties.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/configuration-properties.adoc index 13686a4c..98456b71 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/configuration-properties.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/configuration-properties.adoc @@ -2,11 +2,11 @@ == Configuration Metadata Reference The following 2 reference sections cover documented and well-known properties recognized and processed by -_Spring Data for Apache Geode/Pivotal GemFire_ (SDG) as well as _Spring Session for Apache Geode/Pivotal GemFire_ (SSDG). +_Spring Data for Apache Geode/_ (SDG) as well as _Spring Session for Apache Geode_ (SSDG). These properties may be used in Spring Boot `application.properties` files, or as JVM System properties, to configure -different aspects of or enable individual features of Apache Geode or Pivotal GemFire in a Spring application. -When combined with the power of Spring Boot, magical things begin to happen. +different aspects of or enable individual features of Apache Geode in a Spring application. When combined with +the power of Spring Boot, magical things begin to happen. [[geode-configuration-metadata-springdata]] === Spring Data Based Properties @@ -20,7 +20,7 @@ property, use `spring.data.gemfire.cache.copy-on-read` in Spring Boot `applicati |===================================================================================================================== | Name | Description | Default | From -| name | Name of the Apache Geode / Pivotal GemFire member. | SpringBasedCacheClientApplication | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#name--[ClientCacheApplication.name] +| name | Name of the Apache Geode member. | SpringBasedCacheClientApplication | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#name--[ClientCacheApplication.name] | locators | Comma-delimited list of Locator endpoints formatted as: locator1[port1],...,locatorN[portN]. | [] | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/PeerCacheApplication.html#locators--[PeerCacheApplication.locators] | use-bean-factory-locator | Enable the SDG BeanFactoryLocator when mixing Spring config with GemFire/Geode native config (e.g. cache.xml) and you wish to configure GemFire objects declared in cache.xml with Spring. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#useBeanFactoryLocator--[ClientCacheApplication.useBeanFactoryLocator] @@ -38,7 +38,7 @@ property, use `spring.data.gemfire.cache.copy-on-read` in Spring Boot `applicati | cache.enable-auto-region-lookup | Configure whether to lookup Regions configured in GemFire/Geode native config and declare them as Spring beans. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableAutoRegionLookup.html#enabled--[EnableAutoRegionLookup.enable] | cache.eviction-heap-percentage | Percentage of heap at or above which the eviction should begin on Regions configured for HeapLRU eviction. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#evictionHeapPercentage--[ClientCacheApplication.evictionHeapPercentage] | cache.eviction-off-heap-percentage | Percentage of off-heap at or above which the eviction should begin on Regions configured for HeapLRU eviction. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#evictionOffHeapPercentage--[ClientCacheApplication.evictionOffHeapPercentage] -| cache.log-level | Configure the log-level of an Apache Geode / Pivotal GemFire cache. | config | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#logLevel--[ClientCacheApplication.logLevel] +| cache.log-level | Configure the log-level of an Apache Geode cache. | config | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#logLevel--[ClientCacheApplication.logLevel] | cache.name | Alias for 'spring.data.gemfire.name'. | SpringBasedCacheClientApplication | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/ClientCacheApplication.html#name--[ClientCacheApplication.name] | cache.compression.bean-name | Name of a Spring bean implementing org.apache.geode.compression.Compressor. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableCompression.html#compressorBeanName--[EnableCompression.compressorBeanName] | cache.compression.region-names | Comma-delimited list of Region names for which compression will be configured. | [] | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableCompression.html#regionNames--[EnableCompression.regionNames] @@ -188,7 +188,7 @@ specified location and limited to the defined size. |===================================================================================================================== | Name | Description | Default | From -| logging.level | Configures the log-level of an Apache Geode / Pivotal GemFire cache; Alias for 'spring.data.gemfire.cache.log-level'. | config | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logLevel--[EnableLogging.logLevel] +| logging.level | Configures the log-level of an Apache Geode cache; Alias for 'spring.data.gemfire.cache.log-level'. | config | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logLevel--[EnableLogging.logLevel] | logging.log-disk-space-limit | Configures the amount of disk space allowed to store log files. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logDiskSpaceLimit--[EnableLogging.logDiskSpaceLimit] | logging.log-file | Configures the pathname of the log file used to log messages. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logFile--[EnableLogging.logFile] | logging.log-file-size | Configures the maximum size of a log file before the log file is rolled. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html#logFileSizeLimit--[EnableLogging.logFileSize] @@ -328,7 +328,7 @@ specified location and limited to the defined size. | service.http.bind-address | Configures the IP address or hostname of the system NIC used by the embedded HTTP server to bind and listen for HTTP(S) connections. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#bindAddress--[EnableHttpService.bindAddress] | service.http.port | Configures the port used by the embedded HTTP server to listen for HTTP(S) connections. | 7070 | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#port--[EnableHttpService.port] | service.http.ssl-require-authentication | Configures whether 2-way HTTP authentication is required. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#sslRequireAuthentication--[EnableHttpService.sslRequireAuthentication] -| service.http.dev-rest-api-start | Configures whether to start the Developer REST API web service. A full installation of Apache Geode or Pivotal GemFire is required and you must set the $GEODE environment variable. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#startDeveloperRestApi--[EnableHttpService.startDeveloperRestApi] +| service.http.dev-rest-api-start | Configures whether to start the Developer REST API web service. A full installation of Apache Geode is required and you must set the $GEODE environment variable. | false | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableHttpService.html#startDeveloperRestApi--[EnableHttpService.startDeveloperRestApi] | service.memcached.port | Configures the port of the embedded Memcached server (service). | 11211| {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableMemcachedServer.html#port--[EnableMemcachedServer.port] | service.memcached.protocol | Configures the protocol used by the embedded Memcached server (service). | ASCII | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableMemcachedServer.html#protocol--[EnableMemcachedServer.protocol] | service.redis.bind-address | Configures the IP address or hostname of the system NIC used by the embedded Redis server to bind an listen for connections. | | {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableRedisServer.html#bindAddress--[EnableRedis.bindAddress] @@ -366,6 +366,5 @@ While it is not recommended to use Apache Geode properties directly in your Spri you from doing so. A complete reference to the Apache Geode specific properties can be found {apache-geode-docs}/reference/topics/gemfire_properties.html[here]. -WARNING: Apache Geode (and Pivotal GemFire) are very strict about the properties that maybe specified in -a `gemfire.properties` file. You cannot mix Spring properties with `gemfire.*` properties in an Apache Geode -or Pivotal GemFire, `gemfire.properties` file. +WARNING: Apache Geode is very strict about the properties that maybe specified in a `gemfire.properties` file. You +cannot mix Spring properties with `gemfire.*` properties in an Apache Geode `gemfire.properties` file. diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/continuous-query.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/continuous-query.adoc index 9d2fd3d5..fe592cb8 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/continuous-query.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/continuous-query.adoc @@ -5,21 +5,20 @@ Arguably, the most invaluable of applications are those that can process a strea and intelligently react in near real-time to the countless changes in the data over time. The most useful of frameworks are those that can make processing a stream of events as they happen, as easy as possible. -Spring Boot for Apache Geode & Pivotal GemFire does just that, without users having to perform any complex setup -or configure any necessary infrastructure components to enable such functionality. Developers can simply define -the criteria for the data they are interested in and implement a handler to process the stream of events -as they occur. +Spring Boot for Apache Geode does just that, without users having to perform any complex setup or configure any +necessary infrastructure components to enable such functionality. Developers can simply define the criteria for +the data they are interested in and implement a handler to process the stream of events as they occur. -Apache Geode & Pivotal GemFire make defining criteria for data of interests easy when using +Apache Geode make defining criteria for data of interests easy when using {apache-geode-docs}/developing/continuous_querying/chapter_overview.html[Continuous Query (CQ)]. With CQ, you can -express the criteria matching the data of interests using a query predicate. Apache Geode & Pivotal GemFire implements +express the criteria matching the data of interests using a query predicate. Apache Geode implements the {apache-geode-docs}/developing/querying_basics/query_basics.html[Object Query Language (OQL)] for defining and executing queries. OQL is not unlike SQL, and supports projections, query predicates, ordering and aggregates. And, when used in CQs, they execute continuously, firing events when the data changes in such ways as to match the criteria expressed in the query predicate. -Spring Boot for Apache Geode/Pivotal GemFire combines the ease of expressing interests in data using an OQL -query statement with implementing the listener handler callback, in 1 easy step. +Spring Boot for Apache Geode combines the ease of expressing interests in data using an OQL query statement with +implementing the listener handler callback, in 1 easy step. For example, suppose we want to perform some follow up action anytime a customer's financial loan application is either approved or denied. @@ -38,7 +37,7 @@ class EligibilityDecision { private final Timespan timespan; - ... + // ... enum Status { @@ -64,7 +63,7 @@ class EligibilityDecisionPostProcessor { FROM /EligibilityDecisions decisions WHERE decisions.getStatus().name().equalsIgnoreCase('APPROVED')") public void processApprovedDecisions(CqEvent event) { - ... + // ... } @ContinuousQuery(name = "DeniedDecisionsHandler", @@ -72,7 +71,7 @@ class EligibilityDecisionPostProcessor { FROM /EligibilityDecisions decisions WHERE decisions.getStatus().name().equalsIgnoreCase('DENIED')") public void processDeniedDecisions(CqEvent event) { - ... + // ... } } ---- @@ -83,6 +82,5 @@ anyway you like. And, because our Continuous Query handler class is a component `ApplicationContext`, you can auto-wire any other beans necessary to carry out the application's intended function. This is not unlike Spring's {spring-framework-docs}/integration.html#jms-annotated[Annotation-driven listener endpoints] -used in (JMS) message listeners/handlers, except in Spring Boot for Apache Geode/Pivotal GemFire, you do not need to do -anything special to enable this functionality. Just declare the `@ContinuousQuery` annotation on any POJO method -and off you go. +used in (JMS) message listeners/handlers, except in Spring Boot for Apache Geode, you do not need to do anything special +to enable this functionality. Just declare the `@ContinuousQuery` annotation on any POJO method and off you go. diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/data-serialization.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/data-serialization.adoc index b779d944..55ac19cc 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/data-serialization.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/data-serialization.adoc @@ -2,26 +2,26 @@ == Data Serialization with PDX Anytime data is overflowed or persisted to disk, transferred between clients and servers, peers in a cluster or between -different clusters in a multi-site topology, then all data stored in Apache Geode/Pivotal GemFire must be serializable. +different clusters in a multi-site topology, then all data stored in Apache Geode must be serializable. To serialize objects in Java, object types must implement the `java.io.Serializable` interface. However, if you have a large number of application domain object types that currently do not implement `java.io.Serializable`, then refactoring hundreds or even thousands of class types to implement `Serializable` would be a tedious task just to -store and manage those objects in Apache Geode or Pivotal GemFire. +store and manage those objects in Apache Geode. Additionally, it is not just your application domain object types you necessarily need to worry about either. If you used 3rd party libraries in your application domain model, any types referred to by your application domain object types -stored in Apache Geode or Pivotal GemFire must be serializable too. This type explosion may bleed into class types -for which you may have no control over. +stored in Apache Geode must be serializable too. This type explosion may bleed into class types for which you may have +no control over. Furthermore, Java serialization is not the most efficient format given that meta-data about your types is stored with the data itself. Therefore, even though Java serialized bytes are more descriptive, it adds a great deal of overhead. -Then, along came serialization using Apache Geode or Pivotal GemFire's {apache-geode-docs}/developing/data_serialization/gemfire_pdx_serialization.html[PDX] +Then, along came serialization using Apache Geode {apache-geode-docs}/developing/data_serialization/gemfire_pdx_serialization.html[PDX] format. PDX stands for _Portable Data Exchange_, and achieves 4 goals: -1. Separates type meta-data from the data itself making the bytes more efficient during transfer. Apache Geode -and Pivotal GemFire maintain a type registry storing type meta-data about the objects serialized using PDX. +1. Separates type meta-data from the data itself making the bytes more efficient during transfer. Apache Geode maintains +a type registry storing type meta-data about the objects serialized using PDX. 2. Supports versioning as your application domain types evolve. It is not uncommon to have old and new applications deployed to production, running simultaneously, sharing data, and possibly using different versions of the same domain @@ -50,7 +50,7 @@ de-serializing the object bytes since it involves a method invocation, which def preserving format to avoid the cost of de/serialization. However, we think the benefits of using PDX greatly outweigh the limitations and therefore have enabled PDX by default -when using Spring Boot for Apache Geode/Pivotal GemFire. +when using Spring Boot for Apache Geode. There is nothing special you need to do. Simply code your types and rest assured that objects of those types will be properly serialized when overflowed/persisted to disk, transferred between clients and servers, or peers in a cluster @@ -61,17 +61,17 @@ and even when data is transferred over the WAN when using GemFire/Geode's multi- ---- @Region("EligibilityDecisions") class EligibilityDecision { - ... + // ... } ---- -TIP: Apache Geode/Pivotal GemFire does {apache-geode-docs}/developing/data_serialization/java_serialization.html[support] -the standard Java Serialization format. +TIP: Apache Geode does {apache-geode-docs}/developing/data_serialization/java_serialization.html[support] the standard +Java Serialization format. === SDG `MappingPdxSerializer` vs. GemFire/Geode's `ReflectionBasedAutoSerializer` -Under-the-hood, Spring Boot for Apache Geode/Pivotal GemFire {spring-data-geode-docs-html}/#bootstrap-annotation-config-pdx[enables] -and uses Spring Data for Apache Geode/Pivotal GemFire's {spring-data-geode-javadoc}/org/springframework/data/gemfire/mapping/MappingPdxSerializer.html[MappingPdxSerializer] +Under-the-hood, Spring Boot for Apache Geode {spring-data-geode-docs-html}/#bootstrap-annotation-config-pdx[enables] +and uses Spring Data for Apache Geode's {spring-data-geode-javadoc}/org/springframework/data/gemfire/mapping/MappingPdxSerializer.html[MappingPdxSerializer] to serialize your application domain objects using PDX. TIP: Refer to the SDG {spring-data-geode-docs-html}/#mapping.pdx-serializer[Reference Guide] for more details @@ -104,7 +104,7 @@ with Spring Data's {spring-data-commons-javadoc}/org/springframework/data/annota of nested entity field/property types. Number two above deserves special attention since the `MappingPdxSerializer` "excludes" all Java, Spring -and Apache Geode/Pivotal GemFire types, by default. But, what happens when you need to serialize 1 of those types? +and Apache Geode types, by default. But, what happens when you need to serialize 1 of those types? For example, suppose you need to be able to serialize objects of type `java.security.Principal`. Well, then you can override the excludes by registering an "include" type filter, like so: @@ -114,7 +114,6 @@ override the excludes by registering an "include" type filter, like so: package example.app; import java.security.Principal; -import ...; @SpringBootApplication @EnablePdx(serializerBeanName = "myCustomMappingPdxSerializer") diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/functions.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/functions.adoc index b40cff7b..7d055980 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/functions.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/functions.adoc @@ -15,21 +15,20 @@ Additionally, when the computations are handled in parallel, across the cluster can be performed much faster. This typically involves intelligently organizing the data using various partitioning (a.k.a. sharding) strategies to uniformly balance the data set across the cluster. -Well, both Apache Geode and Pivotal GemFire address this very important application concern in its +Well, Apache Geode address this very important application concern in its {apache-geode-docs}/developing/function_exec/chapter_overview.html[Function Execution] framework. -Spring Data for Apache Geode/Pivotal GemFire {spring-data-geode-docs-html}/#function-annotations[builds] on -this Function Execution framework by enabling developers to {spring-data-geode-docs-html}/#function-implementation[implement] +Spring Data for Apache Geode {spring-data-geode-docs-html}/#function-annotations[builds] on this Function Execution +framework by enabling developers to {spring-data-geode-docs-html}/#function-implementation[implement] and {spring-data-geode-docs-html}/#function-execution[execute] GemFire/Geode Functions using a very simple POJO-based, annotation configuration model. TIP: See {spring-data-geode-docs-html}/#_implementation_vs_execution[here] for the difference between Function implementation & executions. -Taking this 1 step further, Spring Boot for Apache Geode/Pivotal GemFire _auto-configures_ and enables both Function -implementation and execution out-of-the-box. Therefore, you can immediately begin writing Functions and invoking them -without having to worry about all the necessary plumbing to begin with. You can rest assured that it will just work -as expected. +Taking this 1 step further, Spring Boot for Apache Geode _auto-configures_ and enables both Function implementation +and execution out-of-the-box. Therefore, you can immediately begin writing Functions and invoking them without having +to worry about all the necessary plumbing to begin with. You can rest assured that it will just work as expected. === Applying Functions @@ -58,7 +57,7 @@ class EligibilityDeterminationFunction { @GemfireFunction(HA = true, hasResult = true, optimizeForWrite=true) public EligibilityDecision determineEligibility(FunctionContext functionContext, Person person, Timespan timespan) { - ... + // ... } } ---- @@ -97,7 +96,7 @@ class FinancialLoanApplicationService { this.execution = execution; } - @Cacheable("EligibilityDecisions", ...) + @Cacheable("EligibilityDecisions") EligibilityDecision processEligility(Person person, Timespan timespan) { return this.execution.determineEligibility(person, timespan); } @@ -105,6 +104,6 @@ class FinancialLoanApplicationService { ---- Just like caching, no addition configuration is required to enable and find your application Function implementations -and executions. Simply build and run. Spring Boot for Apache Geode/Pivotal GemFire handles the rest. +and executions. Simply build and run. Spring Boot for Apache Geode handles the rest. TIP: It is common to implement and register your application Functions on the server and execute them from the client. diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/gemfire-properties.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/gemfire-properties.adoc index 095d3c96..b96c8a60 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/gemfire-properties.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/gemfire-properties.adoc @@ -1,6 +1,6 @@ [[geode-configuration-gemfire-properties]] == Using Geode Properties -:gemfire-name: Pivotal GemFire +:gemfire-name: VMWare Tanzu GemFire :geode-name: Apache Geode As of Spring Boot for {geode-name} & {gemfire-name} (SBDG) 1.3, it is now possible to declare {geode-name} diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/geode-api-ext.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/geode-api-ext.adoc index e7ca9e39..51b2a080 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/geode-api-ext.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/geode-api-ext.adoc @@ -1,6 +1,6 @@ [[geode-api-extensions]] == Apache Geode API Extensions -:gemfire-name: Pivotal GemFire +:gemfire-name: VMware Tanzu GemFire :geode-name: Apache Geode :images-dir: ./images diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/logging.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/logging.adoc index 7c7bc5f5..bb402cd0 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/logging.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/logging.adoc @@ -16,15 +16,15 @@ e.g. `log-level` no longer have any effect, regardless of whether the property ( TIP: Refer to Apache Geode's {apache-geode-docs}/reference/topics/gemfire_properties.html[Documentation] for a complete list of valid `Properties`, including the `Properties` used to configure logging. -Unfortunately, this also means the _Spring Data for Apache Geode & Pivotal GemFire_ (SDG) +Unfortunately, this also means the _Spring Data for Apache Geode_ (SDG) {spring-data-geode-javadoc}/org/springframework/data/gemfire/config/annotation/EnableLogging.html[`@EnableLogging`] -annotation no longer has any effect on Apache Geode or Pivotal GemFire logging either and is the reason it has been +annotation no longer has any effect on Apache Geode logging either and is the reason it has been https://jira.spring.io/browse/DATAGEODE-299[deprecated]. The reason `@EnableLogging` no longer has any effect on logging is because this annotation's attributes and associated SDG properties indirectly sets the corresponding -Apache Geode or Pivotal GemFire properties, which again, are useless from Apache Geode `1.9.2` onward. +Apache Geode properties, which again, are useless from Apache Geode `1.9.2` onward. -By way of example, and to make this concrete, **none** of the following approaches have any effect on Apache Geode -or Pivotal GemFire logging: +By way of example, and to make this concrete, **none** of the following approaches have any effect +on Apache Geode logging: .Command-line configuration [source,txt] @@ -36,7 +36,7 @@ $ java -classpath ...:/path/to/MySpringBootApacheGeodeClientCacheApplication.jar .Externalized configuration using Apache Geode `gemfire.properties` [source,properties] ---- -# Apache Geode/Pivotal GemFire only/specific properties +# Apache Geode only/specific properties log-level=INFO ---- @@ -66,11 +66,11 @@ class MySpringBootApacheGeodeClientApplication { That is to say, none of the approaches above have any effect without the **new** SBDG logging starter. [[geode-logging-configuration]] -=== Configure Apache Geode & Pivotal GemFire Logging +=== Configure Apache Geode Logging -So, how do you configure logging for Apache Geode and Pivotal GemFire? +So, how do you configure logging for Apache Geode? -Effectively, 3 things are required to get Apache Geode or Pivotal GemFire to log output: +Effectively, 3 things are required to get Apache Geode to log output: 1) First, you must declare a logging provider on your Spring Boot application classpath (e.g. _Logback_). @@ -103,7 +103,7 @@ or bridges `java.util.logging` (JUL) and Apache Log4j to SLF4J. However, you st configuration, such as a `logback.xml` file for _Logback_, to configure logging not only for your Spring Boot application, but also for Apache Geode as well. -SBDG has simplified the setup of Apache Geode and Pivotal GemFire logging. Simply declare the +SBDG has simplified the setup of Apache Geode logging. Simply declare the `org.springframework.geode:spring-geode-starter-logging` dependency on your Spring Boot application classpath! Unlike Apache Geode's default Log4j XML configuration file (i.e. `log4j2.xml`), SBDG's provided `logback.xml` @@ -129,8 +129,8 @@ SBDG's _Logback_ configuration defines 3 Loggers to control the log output from ---- -The `com.gemstone.gemfire` Logger is a legacy Logger covering old Pivotal GemFire bits still present in Apache Geode -for backwards compatibility reasons. This Logger's use should be largely unnecessary. +The `com.gemstone.gemfire` Logger is a legacy Logger covering old VMware Tanzu GemFire bits still present +in Apache Geode for backwards compatibility reasons. This Logger's use should be largely unnecessary. The `org.apache.geode` Logger is the primary Logger used to control log output from all Apache Geode components during the runtime operation of Apache Geode. Both this Logger and the legacy `com.gemstone.gemfire` Logger default @@ -238,7 +238,7 @@ For example, you could compose both the _Logback_ `ConsoleAppender` and `FileApp .Composing multiple `Appenders` [source,java] ---- -ConsoleAppender consoleAppender = ...; +ConsoleAppender consoleAppender = ... ; FileAppender fileAppender = ...; diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/repositories.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/repositories.adoc index 2897a662..2f9ed4bd 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/repositories.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/repositories.adoc @@ -1,17 +1,16 @@ [[geode-repositories]] == Spring Data Repositories -Using Spring Data Repositories with Apache Geode or Pivotal GemFire makes short work of data access operations when -using either Apache Geode or Pivotal GemFire as your System of Record (SOR) to persist your application's state. +Using Spring Data Repositories with Apache Geode makes short work of data access operations when using Apache Geode +as your System of Record (SOR) to persist your application's state. {spring-data-commons-docs-html}/#repositories[Spring Data Repositories] provides a convenient and highly powerful way to define basic CRUD and simple query data access operations easily just by specifying the contract of those data access operations in a Java interface. -Spring Boot for Apache Geode & Pivotal GemFire _auto-configures_ the Spring Data for Apache Geode/Pivotal GemFire -{spring-data-geode-docs-html}/#gemfire-repositories[Repository extension] when either is declared on your application's -classpath. You do not need to do anything special to enable it. Simply start coding your application-specific -Repository interfaces and the way you go. +Spring Boot for Apache Geode _auto-configures_ the Spring Data for Apache Geode {spring-data-geode-docs-html}/#gemfire-repositories[Repository extension] +when declared on your application's classpath. You do not need to do anything special to enable it. Simply start +coding your application-specific Repository interfaces and the way you go. For example: @@ -83,5 +82,5 @@ class SpringBootApacheGeodeClientCacheApplication { ---- Again, see Spring Data Commons' {spring-data-commons-docs-html}/#repositories[Repositories abstraction] in general, -and Spring Data for Apache Geode/Pivotal GemFire {spring-data-geode-docs-html}/#gemfire-repositories[Repositories extension] +and Spring Data for Apache Geode {spring-data-geode-docs-html}/#gemfire-repositories[Repositories extension] in particular, for more details. diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/samples.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/samples.adoc index 6aab0500..4d6ede8c 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/samples.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/samples.adoc @@ -1,12 +1,11 @@ [[geode-samples]] == Samples -This section contains working examples demonstrating how to use Spring Boot for Apache Geode and Pivotal GemFire (SBDG) -effectively. +This section contains working examples demonstrating how to use Spring Boot for Apache Geode (SBDG) effectively. Some examples focus on specific Use Cases (e.g. [(HTTP) Session state] caching) while other examples demonstrate how SBDG works under-the-hood to give users a better understanding of what is actually happening and how to debug problems -with their Apache Geode / Pivotal GemFire, Spring Boot applications. +with their Apache Geode, Spring Boot applications. .Example Spring Boot applications using Apache Geode |=== @@ -17,15 +16,15 @@ with their Apache Geode / Pivotal GemFire, Spring Boot applications. applications with Spring Boot. | {github-samples-url}/intro/getting-started[Getting Started] -| link:guides/boot-configuration.html[Spring Boot Auto-Configuration for Apache Geode/Pivotal GemFire] +| link:guides/boot-configuration.html[Spring Boot Auto-Configuration for Apache Geode] | Explains what auto-configuration is provided by SBDG out-of-the-box and what the auto-configuration is doing. | {github-samples-url}/boot/configuration[Boot Auto-Configuration] -| link:guides/boot-actuator.html[Spring Boot Actuator for Apache Geode/Pivotal GemFire] +| link:guides/boot-actuator.html[Spring Boot Actuator for Apache Geode] | Explains how to use Spring Boot Actuator for Apache Geode and how it works. | {github-samples-url}/boot/actuator[Boot Actuator] -| link:guides/boot-security.html[Spring Boot Security for Apache Geode/Pivotal GemFire] +| link:guides/boot-security.html[Spring Boot Security for Apache Geode] | Explains how to configure Auth and TLS with SSL when using Apache Geode and Pivotal Cloud Cache in Spring Boot applications. | {github-samples-url}/boot/security[Boot Security] diff --git a/spring-geode-docs/src/docs/asciidoc/_includes/templates.adoc b/spring-geode-docs/src/docs/asciidoc/_includes/templates.adoc index fad38dc8..1733056c 100644 --- a/spring-geode-docs/src/docs/asciidoc/_includes/templates.adoc +++ b/spring-geode-docs/src/docs/asciidoc/_includes/templates.adoc @@ -20,11 +20,11 @@ the core Spring Framework. Other Spring Data modules, such as Spring Data Redis, offer the https://docs.spring.io/spring-data/redis/docs/current/api/org/springframework/data/redis/core/RedisTemplate.html[RedisTemplate], -and Spring Data for Apache Geode/Pivotal GemFire (SDG) offers the +and Spring Data for Apache Geode (SDG) offers the {spring-data-gemfire-javadoc}/org/springframework/data/gemfire/GemfireTemplate.html[GemfireTemplate]. The `GemfireTemplate` provides a highly consistent and familiar API to perform data access operations on Apache Geode -or Pivotal GemFire cache `Regions`. +cache `Regions`. `GemfireTemplate` offers: @@ -33,8 +33,8 @@ or Pivotal GemFire cache `Regions`. 3. Automatic enlistment in the presence of local, cache transactions. 4. Protection from {apache-geode-javadoc}/org/apache/geode/cache/Region.html[Region API] breaking changes. -Given these conveniences, Spring Boot for Apache Geode & Pivotal GemFire (SBDG) will auto-configure `GemfireTemplate` -beans for each Region present in the GemFire/Geode cache. +Given these conveniences, Spring Boot for Apache Geode (SBDG) will auto-configure `GemfireTemplate` beans for each +Region present in the cache. Additionally, SBDG is careful not to create a `GemfireTemplate` if the user has already declared a `GemfireTemplate` bean in the Spring `ApplicationContext` for a given Region. @@ -51,7 +51,7 @@ class GemFireConfiguration { @Bean("Example") ClientRegionFactoryBean exampleRegion (GemFireCache gemfireCache) { - ... + // ... } } ---- @@ -88,7 +88,7 @@ Given the following entity class: ---- @Region("Customers") class Customer { - ... + // ... } ---- @@ -97,9 +97,9 @@ And configuration: [source,java] ---- @Configuration -@EnableEntityDefinedRegions(basePackageClasses = Customer.class} +@EnableEntityDefinedRegions(basePackageClasses = Customer.class) class GemFireConfiguration { - ... + // ... } ---- @@ -127,9 +127,8 @@ explicitly or implicitly, such as when using the `@EnableEntityDefineRegions` an SBDG auto-configures `GemfireTemplate` beans for Caching-defined Regions. When you are using Spring Framework's {spring-framework-docs}/integration.html#cache[Cache Abstraction] backed by -either Apache Geode or Pivotal GemFire, 1 of the requirements is to configure Regions for each of the caches specified -in the {spring-framework-docs}integration.html#cache-annotations[Caching Annotations] of your application service -components. +Apache Geode, 1 of the requirements is to configure Regions for each of the caches specified in the +{spring-framework-docs}integration.html#cache-annotations[Caching Annotations] of your application service components. Fortunately, SBDG makes enabling and configuring caching easy and <> out-of-the-box. @@ -183,8 +182,8 @@ when autowiring does not. [[geode-data-access-region-templates-native-defined]] === Native-defined Regions -SBDG will even auto-configure `GemfireTemplate` beans for Regions defined using Apache Geode and Pivotal GemFire native -configuration meta-data, such as `cache.xml`. +SBDG will even auto-configure `GemfireTemplate` beans for Regions defined using Apache Geode native configuration +metadata, such as `cache.xml`. Given the following GemFire/Geode native `cache.xml`: @@ -208,7 +207,7 @@ And Spring configuration: @Configuration @EnableGemFireProperties(cacheXmlFile = "cache.xml") class GemFireConfiguration { - ... + // ... } ---- @@ -243,7 +242,7 @@ class GemFireConfiguration { @Bean public GemfireTemplate customersTemplate(GemFireCache cache) { - return new GemfireTemplate(cache.getRegion("/Customers"); + return new GemfireTemplate(cache.getRegion("/Customers")); } } ---- @@ -254,7 +253,7 @@ Using our same Customers class, as above: ---- @Region("Customers") class Customer { - ... + // ... } ---- @@ -278,7 +277,7 @@ class GemFireConfiguration { @Bean public GemfireTemplate vipCustomersTemplate(GemFireCache cache) { - return new GemfireTemplate(cache.getRegion("/Customers"); + return new GemfireTemplate(cache.getRegion("/Customers")); } } ---- diff --git a/spring-geode-docs/src/docs/asciidoc/guides/caching-inline.adoc b/spring-geode-docs/src/docs/asciidoc/guides/caching-inline.adoc index 3776326a..6c4e995d 100644 --- a/spring-geode-docs/src/docs/asciidoc/guides/caching-inline.adoc +++ b/spring-geode-docs/src/docs/asciidoc/guides/caching-inline.adoc @@ -160,10 +160,9 @@ expired or been evicted. We neither configure eviction nor expiration for this Both the `factorial(..)` and `sqrt(..)` methods have been annotated with Spring's `@Cacheable` annotation to demarcate these methods with caching behavior. Of course, as explained in SBDG's <<../_includes/configuration-annotations.adoc#geode-caching-provider,documentation>>, -caching with Spring's Cache Abstraction using Apache Geode (or Pivotal GemFire, even Pivotal Cloud Cache (PCC) -when running in Pivotal CloudFoundry (PCF)) as the caching provider is enabled by default. Therefore, there is nothing -more you need do to start leverage caching in your Spring Boot applications than to annotate the service methods -with the appropriate Spring or JSR-107, JCache API annotations. Simple! +caching with Spring's Cache Abstraction using Apache Geode as the caching provider is enabled by default. Therefore, +there is nothing more you need do to start leverage caching in your Spring Boot applications than to annotate +the service methods with the appropriate Spring or JSR-107, JCache API annotations. Simple! It is worth noting that we are starting with the same applied pattern of caching as you would when using the _Look-Aside Caching_ pattern. This is key to minimizing the invasive nature of _Inline Caching_. There is a subtle @@ -187,7 +186,7 @@ The pertinent part of the configuration that enables _Inline Caching_ for our Ca the `inlineCachingForCalculatorApplicationRegionsConfigurer` bean definition. SBDG provides the `InlineCachingRegionConfigurer` class used in the bean definition to configure and enable the caches -(a.k.a. as Regions in Apache Geode & Pivotal GemFire terminology) with _Inline Caching_ behavior. +(a.k.a. as Regions in Apache Geode terminology) with _Inline Caching_ behavior. The Configurer's job is to configure the appropriate Spring Data (SD) _Repository_ used as a Region's `CacheLoader` for "_read-through_" behavior as well as configure the same SD _Repository_ for a Region's `CacheWriter` for @@ -260,9 +259,9 @@ these Regions for you. TIP: If you have not done so already, you should definitely read about SBDG's support for _Inline Caching_ in the link:../index.html#geode-caching-provider-inline-caching[Inline Caching] section. -TIP: To learn more about how Apache Geode's (or Pivotal GemFire's) data loading functionality works, or specifically, -how to {apache-geode-docs}/developing/outside_data_sources/sync_outside_data.html["Keep the Cache in Sync with Outside -Data Sources"] follow the link. You may also learn more by reading the _Javadoc_ for +TIP: To learn more about how Apache Geode's data loading functionality works, or specifically, how to +{apache-geode-docs}/developing/outside_data_sources/sync_outside_data.html["Keep the Cache in Sync with Outside Data Sources"] +follow the link. You may also learn more by reading the _Javadoc_ for {apache-geode-javadoc}//org/apache/geode/cache/CacheLoader.html[`CacheLoader`] and {apache-geode-javadoc}/org/apache/geode/cache/CacheWriter.html[`CacheWriter`]. diff --git a/spring-geode-docs/src/docs/asciidoc/guides/caching-look-aside.adoc b/spring-geode-docs/src/docs/asciidoc/guides/caching-look-aside.adoc index a6ba1d2e..abe301b1 100644 --- a/spring-geode-docs/src/docs/asciidoc/guides/caching-look-aside.adoc +++ b/spring-geode-docs/src/docs/asciidoc/guides/caching-look-aside.adoc @@ -173,9 +173,8 @@ With the `org.springframework.geode:spring-geode-starter` dependency on your app And the `BootGeodeLookAsideCachingApplication` class annotated with `@SpringBootApplication`, you have everything you need to begin using Spring's _Cache Abstraction_ in your application with Apache Geode as the caching provider. -TIP: You can switch from open source Apache Geode to Pivotal GemFire (PCC) very easily simply by changing -the artifactId from `spring-geode-starter` to `spring-gemfire-starter`. No configuration or code changes -are necessary. +TIP: You can switch from open source Apache Geode to VMware Tanzu GemFire very easily simply by changing the artifactId +from `spring-geode-starter` to `spring-gemfire-starter`. No configuration or code changes are necessary. As an application developer, all you need do is focus on where in your application caching would be most beneficial. @@ -246,9 +245,8 @@ After running the `BootGeodeLookAsideCachingApplication` class, if you open a We [[geode-samples-caching-lookaside-example-counterservice-configuration]] === Counter Service Configuration -While Spring Boot for Apache Geode/Pivotal GemFire (PCC), SBDG, takes care of enabling Spring's caching infrastructure -for you, configuring Apache Geode/Pivotal GemFire (PCC) as a caching provider, you still must define and declare -your individual caches. +While Spring Boot for Apache Geode (SBDG) takes care of enabling Spring's caching infrastructure for you, configuring +Apache Geode as a caching provider, you still must define and declare your individual caches. No Spring caching provider is fully configured by Spring or Spring Boot for that matter. Part of the reason for this is that there are many different ways to configure the caches. @@ -268,9 +266,9 @@ include::{samples-dir}/caching/look-aside/src/main/java/example/app/caching/look ---- The only thing of real significance here is the `@EnableCachingDefinedRegions` annotation. This Spring Data -for Apache Geode/Pivotal GemFire (SDG) annotation is responsible for introspecting our Spring Boot application -on Spring container startup, identifying all the caching annotations (both Spring Cache annotations as wells JSR-107, -JCache annotations) used in our application components, and creating the appropriate caches. +for Apache Geode (SDG) annotation is responsible for introspecting our Spring Boot application on Spring container +startup, identifying all the caching annotations (both Spring Cache annotations as wells JSR-107, JCache annotations) +used in our application components, and creating the appropriate caches. If you were not using SDG's `@EnablingCachingDefinedRegions` annotation, then you would need to define the Region using the equivalent _JavaConfig_: @@ -547,9 +545,9 @@ B | 2 As you have learned, Spring makes enabling and using caching in your application really easy. -With SBDG, using either Apache Geode or Pivotal GemFire as your caching provider in Spring's _Cache Abstraction_ -is as easy as making sure `org.springframework.geode:spring-geode-starter` is on your application's classpath. You just -need to focus on areas of your application that would benefit from caching. +With SBDG, using Apache Geode as your caching provider in Spring's _Cache Abstraction_ is as easy as making sure +`org.springframework.geode:spring-geode-starter` is on your application's classpath. You just need to focus on areas +of your application that would benefit from caching. You have now successfully used the _**Look-Aside Caching**_ pattern in your Spring Boot application. diff --git a/spring-geode-docs/src/docs/asciidoc/guides/caching-near.adoc b/spring-geode-docs/src/docs/asciidoc/guides/caching-near.adoc index 5a9ed496..a2a2047b 100644 --- a/spring-geode-docs/src/docs/asciidoc/guides/caching-near.adoc +++ b/spring-geode-docs/src/docs/asciidoc/guides/caching-near.adoc @@ -168,7 +168,7 @@ include::{samples-dir}/caching/near/src/main/java/example/app/caching/near/serve ---- TIP: For more information on configurating and bootstrapping a small cluster of {apache-geode-name} servers using Spring Boot, -see link:../index.html#geode-cluster-configuration-bootstrapping[Running an {apache-geode-name} or Pivotal GemFire Cluster using Spring Boot]. +see link:../index.html#geode-cluster-configuration-bootstrapping[Running an {apache-geode-name} Cluster using Spring Boot]. [[geode-samples-caching-near-example-client-side]] === Client-side Configuration diff --git a/spring-geode-docs/src/docs/asciidoc/guides/getting-started.adoc b/spring-geode-docs/src/docs/asciidoc/guides/getting-started.adoc index 8b30b478..f5257925 100644 --- a/spring-geode-docs/src/docs/asciidoc/guides/getting-started.adoc +++ b/spring-geode-docs/src/docs/asciidoc/guides/getting-started.adoc @@ -29,33 +29,33 @@ John Blum :docinfodir: guides -This guide walks you through building and running a simple Spring Boot, Apache Geode `ClientCache` application -using the Spring Boot for Apache Geode (SBDG) framework. Later in this guide, we switch the application from -{apache-geode-website}[Apache Geode] to {pivotal-cloudcache-website}[Pivotal Cloud Cache] and deploy (i.e `_push_`) +This guide walks you through building and running a simple Spring Boot, {geode-name} `ClientCache` application +using the Spring Boot for {geode-name} (SBDG) framework. Later in this guide, we switch the application from +{apache-geode-website}[{geode-name}] to {pivotal-cloudcache-website}[{cloudcache-name}] and deploy (i.e `_push_`) the application up to {pivotal-cloudfoundry-website}[_Pivotal Platform_]. Specifically, you will: -1. Create a new "_Spring for Apache Geode_" project using _Spring Initializer_ at https://start.spring.io[start.spring.io]. +1. Create a new "_Spring for {geode-name}_" project using _Spring Initializer_ at https://start.spring.io[start.spring.io]. Goto the <> topic. -2. Then, we build a simple Spring Boot, Apache Geode `ClientCache` application that can persist data locally -in Apache Geode. Goto the <> topic. +2. Then, we build a simple Spring Boot, {geode-name} `ClientCache` application that can persist data locally +in {geode-name}. Goto the <> topic. 3. Next, we switch the application from running locally to using a client/server topology. Goto the <> topic. 4. And finally, we deploy the application to _Pivotal Platform_ and bind our application to a provisioned -_Pivotal Cloud Cache_ (PCC) service instance. +_{cloudcache-name}_ (PCC) service instance. Goto the <> topic. Our goal is to accomplish each step with _little to no code or configuration_ changes. It should just work! NOTE: It is also possible to migrate from a Commercial, Managed environment (running in _Pivotal Platform_ -using _Pivotal Cloud Cache_ (PCC)) back to an Open Source, Non-Managed environment (i.e. running with an externally -managed Apache Geode cluster). +using _{cloudcache-name}_ (PCC)) back to an Open Source, Non-Managed environment (i.e. running with an externally +managed {geode-name} cluster). By the end of this guide, you should feel comfortable and ready to begin building Spring Boot applications using either -Apache Geode standalone or by deploying and running in _Pivotal Platform_ using _Pivotal Cloud Cache_ (PCC). +{geode-name} standalone or by deploying and running in _Pivotal Platform_ using _{cloudcache-name}_ (PCC). -NOTE: {pivotal-cloudcache-website}[_Pivotal Cloud Cache_] (PCC) has replaced {pivotal-gemfire-website}[_Pivotal GemFire_] +NOTE: {pivotal-cloudcache-website}[_{cloudcache-name}_] (PCC) has replaced {pivotal-gemfire-website}[_{gemfire-name}_] as the new brand name. Let's begin! @@ -80,7 +80,7 @@ When creating the example app for this guide, we selected: ** _Artifact_: **crm** ** _Options_: *** _Package Name_: **example.app.crm** -* _Dependencies_: Add "**Spring for Apache Geode**" by typing "_Geode_" into the "_Search dependencies to add_" +* _Dependencies_: Add "**Spring for {geode-name}**" by typing "_Geode_" into the "_Search dependencies to add_" text field. * (Optional) _Dependencies_: Add "_Spring Web_" to pull in `org.springframework.boot:spring-boot-starter-web` if you want this Spring Boot application to be a Web application. @@ -98,7 +98,7 @@ Your selections should look similar to: image::{images-dir}/spring-initializer-screenshot.png[] -Be sure to click the "*+*" button next to the "_Spring for Apache Geode_" dependency to select and add it to +Be sure to click the "*+*" button next to the "_Spring for {geode-name}_" dependency to select and add it to the generated project Maven POM file. You can explore the contents of the generated project by pressing the `CTRL+SPACE` keys: @@ -112,7 +112,7 @@ Download the ZIP file and unpack it to your desired working directory. You can then use your favorite IDE (e.g. https://www.jetbrains.com/idea/[IntelliJ IDEA] or https://spring.io/tools[Spring Tool Suite] (STS)) to open the generated project. -You are ready to begin developing your Spring Boot, Apache Geode `ClientCache` application. +You are ready to begin developing your Spring Boot, {geode-name} `ClientCache` application. [[about-versions]] .Versions @@ -151,10 +151,10 @@ public class CrmApplication { } ---- -Additionally, in the project Maven POM file, we see the "_Spring Boot for Apache Geode_" (SBDG) dependency +Additionally, in the project Maven POM file, we see the "_Spring Boot for {geode-name}_" (SBDG) dependency (`org.springframework.geode:spring-geode-starter)`: -.Spring Boot for Apache Geode dependency +.Spring Boot for {geode-name} dependency [source,xml] [subs="verbatim,attributes"] ---- @@ -164,9 +164,9 @@ Additionally, in the project Maven POM file, we see the "_Spring Boot for Apache ---- -With the _Spring Boot for Apache Geode_ dependency (i.e. `org.springframework.geode:spring-geode-starter`) +With the _Spring Boot for {geode-name}_ dependency (i.e. `org.springframework.geode:spring-geode-starter`) on the application classpath along with the main Java class being a proper Spring Boot application, this application -will startup and run as an Apache Geode `ClientCache` application: +will startup and run as an {geode-name} `ClientCache` application: .Application log output [source,txt] @@ -634,17 +634,17 @@ Process finished with exit code 0 ---- First, you see the JVM bootstrap Spring Boot, which in turn runs our `CrmApplication` and also auto-configures -and bootstraps an Apache Geode `ClientCache` instance. Most of the output comes from Apache Geode. +and bootstraps an {geode-name} `ClientCache` instance. Most of the output comes from {geode-name}. The application falls straight through because it is not doing anything interesting, and technically, because there are no non-daemon Threads (e.g. Socket Thread listening on HTTP port 8080 in the case of Web applications running an embedded Servlet Container like Apache Tomcat) that prevents the "main" Java Thread from exiting immediately. [[spring-geode-samples-getting-started-build-app]] -== Build a Spring Boot, Apache Geode `ClientCache` application +== Build a Spring Boot, {geode-name} `ClientCache` application Our Spring Boot application is a simple _Customer Relationship Management_ (CRM) application that allows users -to persist `Customer` data in Apache Geode and lookup `Customers` by name. +to persist `Customer` data in {geode-name} and lookup `Customers` by name. [[spring-geode-samples-getting-started-build-app-model]] === `Customer` class @@ -660,15 +660,15 @@ include::{samples-dir}/intro/getting-started/src/main/java/example/app/crm/model The CRM application defines a `Customer` in terms of an identifier (i.e. `Long id`) and a name (i.e. `String name`). Both fields are required. -Additionally, we map `Customer` objects to the "_/Customers_" Region using Spring Data for Apache Geode's (SDG) +Additionally, we map `Customer` objects to the "_/Customers_" Region using Spring Data for {geode-name}'s (SDG) {spring-data-geode-javadoc}/org/springframework/data/gemfire/mapping/annotation/Region.html[`@Region`] annotation. -The `@Region` annotation tells Spring Data where to persist and access `Customer` objects in Apache Geode. It is +The `@Region` annotation tells Spring Data where to persist and access `Customer` objects in {geode-name}. It is basically equivalent to JPA's `@javax.persistence.Table` annotation. Additionally, we annotate the `Long id` field with Spring Data's `@org.springframework.data.annotation.Id` annotation. -This designates the `id` field as the identifier, or in Apache Geode's case, the "key" since a Region is a key/value -store. In fact, Apache Geode's {apache-geode-javadoc}/org/apache/geode/cache/Region.html[`Region`] interface +This designates the `id` field as the identifier, or in {geode-name}'s case, the "key" since a Region is a key/value +store. In fact, {geode-name}'s {apache-geode-javadoc}/org/apache/geode/cache/Region.html[`Region`] interface implements the `java.uti.Map` interface making it a `Map` data structure. We use https://projectlombok.org/[Project Lombok] to simply the implementation of the `Customer` class. @@ -683,7 +683,7 @@ subjective topic on whether to use Lombok in production code. We have no opinio === `CustomerRepository` interface Now that we have defined a basic model for managing customer data, we can create a Spring Data `CrudRepository` used by -our application to persist `Customer` objects to Apache Geode. This same _Repository_ can be used to lookup, or query +our application to persist `Customer` objects to {geode-name}. This same _Repository_ can be used to lookup, or query `Customers` by name. .`CustomerRepository` interface @@ -697,7 +697,7 @@ that enables an application to perform basic CRUD (i.e. CREATE, READ, UPDATE, DE data access operations on a persistent entity (e.g. `Customer`). TIP: Review the Spring Data Commons Reference Guide for more details on {spring-data-commons-docs}/#repositories[Working with Spring Data Repositories] -and Spring Data for Apache Geode's (SDG) {spring-data-geode-docs}/#gemfire-repositories[extension and implementation] +and Spring Data for {geode-name}'s (SDG) {spring-data-geode-docs}/#gemfire-repositories[extension and implementation] of Spring Data Commons Repository Abstraction. [[spring-geode-samples-getting-started-build-app-controller]] @@ -731,7 +731,7 @@ for accessing the CRM application via a Web client (e.g. Web browser). |=== NOTE: If you did not enable the Web components by adding the Spring Web dependency to your application classpath, then -no worries, we will still be inspecting the application's effects on Apache Geode using _Gfsh_ (Apache Geode & Pivotal +no worries, we will still be inspecting the application's effects on {geode-name} using _Gfsh_ ({geode-name} & Pivotal GemFire's shell tool). Of course, you can just add the `org.springframework.boot:spring-boot-starter-web` dependency to your Maven POM file as well. @@ -755,7 +755,7 @@ responsibility as the application developer. One example is Region configuratio There are many ways to configure a Region and it varies significantly from application Use Case to application Use Case. First, there are different data management policies (e.g. `PARTITION` or `REPLICATE`) that might be applicable depending -on the type of data you store in Apache Geode (e.g. Transactional vs. Reference data). You might need different +on the type of data you store in {geode-name} (e.g. Transactional vs. Reference data). You might need different Eviction and Expiration policies depending on your user base or workloads. Some data is suited for Off-Heap memory. Depending on the data management policy of the Region (e.g. `PARTITION`) you can configure additional per node and total Region memory usage restrictions, collocate the Region with another Region for use in JOIN Queries, etc. @@ -765,7 +765,7 @@ especially during development. So, while SBDG may not provide implicit _auto-co this does not mean you are left to figure it all out by yourself (e.g. Region configuration). During development, if you don't care specifically "_how_" your data is stored and you just want to simply and rapidly -iterate, putting and getting data into and out of Apache Geode, then SBDG can help. +iterate, putting and getting data into and out of {geode-name}, then SBDG can help. The first thing we will do is annotate our application configuration with SDG's `@EnableEntityDefinedRegions` annotation and set the `basePackageClasses` attribute to our `Customer` class: @@ -822,12 +822,12 @@ You can also use Spring XML: ==== Configure the Application to be Cluster-Aware The final bit of configuration helps determine whether the client application is by itself or whether a cluster of -Apache Geode servers are available to manage the application's data. +{geode-name} servers are available to manage the application's data. During development, you might be iteratively and rapidly developing inside your IDE, debugging and testing new functions locally and then switch to a client/server environment for further integration testing. -Apache Geode requires 1) all client Regions that send data to/from the cluster be `*PROXY` Regions and 2) that a +{geode-name} requires 1) all client Regions that send data to/from the cluster be `*PROXY` Regions and 2) that a server-side Region by the same name exists in the cluster. Switching the data management policy for all client Regions' from `*PROXY` to `LOCAL` when pulling your application code @@ -887,7 +887,7 @@ to our main `@SpringBootApplication` class: include::{samples-dir}/intro/getting-started/src/main/java/example/app/crm/CrmApplication.java[tags=runner] ---- -The runner creates a new `Customer` "_JonDoe_", persists "_JonDoe_" to Apache Geode in the "_/Customers_" client `LOCAL` +The runner creates a new `Customer` "_JonDoe_", persists "_JonDoe_" to {geode-name} in the "_/Customers_" client `LOCAL` Region, runs an OQL query to lookup "_JonDoe_" by name using a wildcard query with the LIKE operator and argument "_%Doe_", then asserts that the result is correct. @@ -942,7 +942,7 @@ Customer was [Customer(name=JonDoe)] SBDG, with the help of `@EnableEntityDefinedRegions` and `@EnableClusterAware`, along with Spring Data, has already done quite a bit of work for us: -1. SBDG _auto-configured_ a `ClientCache` instance required to use Apache Geode in the application. +1. SBDG _auto-configured_ a `ClientCache` instance required to use {geode-name} in the application. 2. The `@EnableEntityDefinedRegion` annotation created the required "_/Customers_" client Region from our `Customer` entity class. 3. SBDG _auto-configured_ the Spring Data Repository infrastructure and supplied an implementation for @@ -1019,21 +1019,21 @@ image::{images-dir}/customer-service-application-jondoe.png[] [[spring-geode-samples-getting-started-run-app-clientserver]] == Run the Application in a Client/Server Topology -Now that we have a simple Spring Boot, Apache Geode `ClientCache` application running locally inside our IDE, we want to +Now that we have a simple Spring Boot, {geode-name} `ClientCache` application running locally inside our IDE, we want to expand on this bit and switch to a client/server topology. Although we are not quite ready to move to a managed cloud platform environment, like _Pivotal Platform_ (formerly -known as _Pivotal CloudFoundry_) using _Pivotal Cloud Cache_ (PCC), we no longer want to maintain the data locally. +known as _Pivotal CloudFoundry_) using _{cloudcache-name}_ (PCC), we no longer want to maintain the data locally. Without persistence, we would lose all our data if the client application were shutdown since the data is maintained in-memory. Additionally, by maintaining the data locally, other client applications, or even other instances of our existing application (e.g. in a Microservices landscape) would not be able to use this data, which is useless! -To switch to a client/server topology, we need to first configure and bootstrap an Apache Geode cluster. +To switch to a client/server topology, we need to first configure and bootstrap an {geode-name} cluster. The Example Code for this Guide already provides the necessary Geode shell script (_Gfsh_) to start a cluster: -.Gfsh shell script to start an Apache Geode cluster +.Gfsh shell script to start an {geode-name} cluster [source,txt] ---- include::{samples-dir}/intro/getting-started/src/main/resources/geode/bin/start-cluster.gfsh[] @@ -1049,7 +1049,7 @@ gfsh> run --file=@SBDG_HOME@/spring-geode-samples/intro/getting-started/src/main NOTE: Be sure to change the `@SBDG_HOME@` placeholder variable with the location of your cloned copy of SBDG. -The _Gfsh_ shell script starts an Apache Geode cluster with 1 _Locator_ and 2 _Servers_. +The _Gfsh_ shell script starts an {geode-name} cluster with 1 _Locator_ and 2 _Servers_. The output from the shell script will look similar to: @@ -1256,7 +1256,7 @@ the best data management policy and organization for transactional data. The "_ on our 2 _Servers_, "ServerOne" and "ServerTwo". WARNING: You must have redundancy (and optionally, persistence) configured in your cluster to prevent (complete) -data loss, which forms the basis for high-availability (HA) in Apache Geode and Pivotal Cloud Cache (PCC). +data loss, which forms the basis for high-availability (HA) in {geode-name} and {cloudcache-name} (PCC). We can query "_JonDoe_" from _Gfsh_: @@ -1348,10 +1348,10 @@ Once again, SBDG is providing you with tremendous power and convenience that you While there are very apparent things happening, there are also a few non-apparent things happening as well. In addition to the aforementioned things in the last section, we are now benefiting from: -1. SBDG appropriately configured and relied on Apache Geode internal features to connect the client to the cluster. +1. SBDG appropriately configured and relied on {geode-name} internal features to connect the client to the cluster. 2. Configuration metadata for our application's required client Regions (e.g. "_/Customers_") was sent to the cluster and created on the servers to leverage the client/server topology. -3. SBDG _auto-configured_ PDX, Apache Geode's highly powerful Serialization framework and alternative to +3. SBDG _auto-configured_ PDX, {geode-name}'s highly powerful Serialization framework and alternative to _Java Serialization_. Once we migrate to a managed cloud platform environment, we'll see the full effects of SBDG's _auto-configuration_ @@ -1361,14 +1361,14 @@ at play. ***** Anytime you need to send data over the network, persist or overflow data to disk, your objects need to be serializable. -SBDG employs Apache Geode's {apache-geode-docs}/developing/data_serialization/gemfire_pdx_serialization.html[PDX Serialization] +SBDG employs {geode-name}'s {apache-geode-docs}/developing/data_serialization/gemfire_pdx_serialization.html[PDX Serialization] framework so your application entity classes do not need to implement `java.io.Serializable`. In other cases, implementing `java.io.Serializable` may not even be possible if your application domain types are composed of types from 3rd party libraries for which you have no control over. Perhaps you don't want to use _Java Serialization_ given the inherit overhead of the _Java Serialization_ format. -In any case, using Apache Geode PDX Serialization is ideal if you have large number of objects forming a complex graph +In any case, using {geode-name} PDX Serialization is ideal if you have large number of objects forming a complex graph where missing a type that needs to be serialized is easy to do. PDX allows you to query data in serialized form and even allows non-Java clients (e.g. native clients written in C#/C++) to access the same data. @@ -1491,7 +1491,7 @@ gfsh> create region --name=Example --type=PARTITION ... While this can be scripted and the script can be checked into source control (a definitive plus) the same as the application code, you sill need to create matching Regions on the client, for which there is no assistance -provided by Apache Geode or Pivotal Cloud Cache. +provided by {geode-name} or {cloudcache-name}. This is why `@EnableClusterAware` will help you be much more productive during development. After you are ready to promote the application to the next environment, it is a simple matter to {apache-geode-docs}/tools_modules/gfsh/command-pages/export.html#topic_mdv_jgz_ck[export] @@ -1508,16 +1508,16 @@ Again, this is highly recommended in practice. == Run the Application in a Cloud Platform Environment Now that we have built and ran our application locally as well as in a client/server topology, we are ready to push -the application to a managed cloud platform environment, like _Pivotal Platform_ using _Pivotal Cloud Cache_ (PCC). +the application to a managed cloud platform environment, like _Pivotal Platform_ using _{cloudcache-name}_ (PCC). This is the final step in our journey to the cloud and SBDG makes this a non-event! -While SBDG handles most application development concerns, _Pivotal Cloud Cache_ (PCC), in conjunction with +While SBDG handles most application development concerns, _{cloudcache-name}_ (PCC), in conjunction with _Pivotal Platform_, handles most operational concerns. .Using Pivotal Platform ***** -To deploy this application to _Pivotal Platform_ and use _Pivotal Cloud Cache_ (PCC), you will need access to +To deploy this application to _Pivotal Platform_ and use _{cloudcache-name}_ (PCC), you will need access to a _Pivotal Platform_ environment (e.g. PWS) with the PCC tile installed. Please see https://run.pivotal.io/[Pivotal Web Services] (PWS) website for more details on how to get started. @@ -1530,10 +1530,10 @@ See link:../index.html#cloudfoundry-geode[Hybrid Cloud Environments] for more de Once you have acquired a _Pivotal Platform_ environment and installed the required tools (e.g. CF CLI), then you can package the application and deploy (i.e. "_push_") it to _Pivotal Platform_. -Before we package the application, we must switch the "_Spring (Boot) for Apache Geode_" dependency in our application +Before we package the application, we must switch the "_Spring (Boot) for {geode-name}_" dependency in our application Maven POM file from: -.Spring Boot for Apache Geode dependency +.Spring Boot for {geode-name} dependency [source,xml] [subs="verbatim,attributes"] ---- @@ -1546,7 +1546,7 @@ Maven POM file from: To: -.Spring Boot for Pivotal GemFire (a.k.a. Pivotal Cloud Cache (PCC)) dependency +.Spring Boot for {gemfire-name} (a.k.a. {cloudcache-name} (PCC)) dependency [source,xml] [subs="verbatim,attributes"] ---- @@ -1594,23 +1594,23 @@ is the server-side. .Acquiring {cloudcache-name} Bits ***** -In order to acquire the Pivotal Cloud Cache (PCC) / Pivotal GemFire bits used by your Spring Boot application, you must +In order to acquire the {cloudcache-name} (PCC) / {gemfire-name} bits used by your Spring Boot application, you must sign up and register on https://network.pivotal.io/[Pivotal Network] (a.k.a. "_PivNet_"). This should include instructions on how to configure your application Maven POM file with the necessary `` -declaration for acquiring the _Pivotal Cloud Cache_ / Pivotal GemFire bits pulled in by the +declaration for acquiring the _{cloudcache-name}_ / {gemfire-name} bits pulled in by the `org.springframework.geode:spring-gemfire-starter` SBDG application dependency as well as the necessary settings in `~/.m2/settings.xml` to authenticate and access the Pivotal Commercial Repository server. -This is absolutely necessary since Pivotal Cloud Cache (PCC) / Pivotal GemFire bits are not available in _Maven Central_. +This is absolutely necessary since {cloudcache-name} (PCC) / {gemfire-name} bits are not available in _Maven Central_. -You can also find more details on acquiring the bits in the Pivotal GemFire +You can also find more details on acquiring the bits in the {gemfire-name} https://gemfire.docs.pivotal.io/{pivotal-gemfire-version}/gemfire/getting_started/installation/obtain_gemfire_maven.html[documentation]. ***** .Required Spring Boot Actuator Bits ***** -As of Apache Geode 1.9 and Pivotal GemFire 9.8, upon which Pivotal Cloud Cache (PCC) 1.8 is {pivotal-cloudcache-docs}/product-snapshot.html[based], +As of {geode-name} 1.9 and {gemfire-name} 9.8, upon which {cloudcache-name} (PCC) 1.8 is {pivotal-cloudcache-docs}/product-snapshot.html[based], both GemFire and Geode require and declare Micrometer on the classpath as a compile-time dependency. Technically, the Micrometer bits are pulled in by `org.apache.geode:geode-core:1.9.0` and the Micrometer version @@ -1626,7 +1626,7 @@ is determined by the version of Spring Boot you are using: As of this writing, due to an https://github.com/cloudfoundry/java-buildpack-metric-writer/issues/6[Issue] in the _Java buildpack_ for CloudFoundry, you are also required to put Spring Boot Actuator on the classpath -for your Spring Boot application using Apache Geode or PCC: +for your Spring Boot application using {geode-name} or PCC: .Declaring Spring Boot Actuator on the application classpath [source.xml] @@ -1655,7 +1655,7 @@ OUT at o.s.c.a.TypeMappedAnnotation.getValue(TypeMappedAnnotation.java:403) ... ---- -On the other hand, if you try to exclude Micrometer from the Apache Geode or PCC dependency, for example: +On the other hand, if you try to exclude Micrometer from the {geode-name} or PCC dependency, for example: .Excluding the Micrometer dependency from `spring-gemfire-starter` [source,txt] @@ -1675,9 +1675,9 @@ On the other hand, if you try to exclude Micrometer from the Apache Geode or PCC ---- Then, you will get past the _Java buildpack_ Exception, but you will encounter another Exception when Spring Boot -tries to bootstrap Apache Geode on startup: +tries to bootstrap {geode-name} on startup: -.Exception in Apache Geode +.Exception in {geode-name} [source,txt] ---- [OUT] Caused by: java.lang.NoClassDefFoundError: io/micrometer/core/instrument/MeterRegistry @@ -1685,7 +1685,7 @@ tries to bootstrap Apache Geode on startup: ---- Therefore, you must include Spring Boot Actuator on your Spring Boot application classpath when deploying -to Pivotal Platform and using Pivotal Cloud Cache (PCC). Again, the easiest way to do that is include the +to Pivotal Platform and using {cloudcache-name} (PCC). Again, the easiest way to do that is include the `org.springframework.geode:spring-gemfire-starter-actuator` dependency on your application classpath. ***** @@ -1874,12 +1874,12 @@ Again, we see the "_crm-app_". You can click on the app name and drill in to ge image::{images-dir}/pvtl-appsmanager-org-space-apps-crm-app-overview.png[] If you click on "_Service (1)_" in the left navigation bar, you will see that the "_crm-app_" is bound to -the "_pccServiceOne_" Pivotal Cloud Cache service instance: +the "_pccServiceOne_" {cloudcache-name} service instance: image::{images-dir}/pvtl-appsmanager-org-space-apps-crm-app-service.png[] If you click on "_Settings_" in the left navigation bar and "REVEAL ENV VARS" you will find the "_Gfsh login string_" -that you can use to connect to the Pivotal Cloud Cache cluster using _Gfsh_ from your local development environment: +that you can use to connect to the {cloudcache-name} cluster using _Gfsh_ from your local development environment: image::{images-dir}/pvtl-appsmanager-org-space-apps-crm-app-settings.png[] @@ -1993,13 +1993,13 @@ id | name 1 | JonDoe ---- -You successfully deployed the CRM, Spring Boot Apache Geode/Pivotal Cloud Cache `ClientCache` application to the cloud! +You successfully deployed the CRM, Spring Boot {geode-name}/{cloudcache-name} `ClientCache` application to the cloud! In this final incarnation of our CRM, Spring Boot application, SBDG yet again handled many different concerns for us so we did not need to. This is in addition to all the things mentioned above when running the application locally as well as running the application using a client/server topology. Now, we also benefit from: -1. SBDG figures out the connection criteria needed to connect your client to the servers in the Pivotal Cloud Cache +1. SBDG figures out the connection criteria needed to connect your client to the servers in the {cloudcache-name} (PCC) cluster, which is technically extracted from the VCAP environment. SBDG will connect the Spring Boot app to the PCC Locators. 2. SBDG automatically authenticates your Spring Boot app with the PCC cluster providing your app was correctly bound to @@ -2020,10 +2020,10 @@ specifically cover the details of doing so in this guide. Running in a Hybrid Cloud Environment specifically means deploying your CRM, Spring Boot `ClientCache` application to a managed cloud platform environment, such as Pivotal Platform, but connect the app to an externally managed -Apache Geode or Pivotal GemFire cluster, i.e. the GemFire/Geode cluster is running and managed off platform. +{geode-name} or {gemfire-name} cluster, i.e. the GemFire/Geode cluster is running and managed off platform. NOTE: As of this writing, the inverse is also being explored, running your Spring Boot applications off platform, -but connecting those apps to managed data services (e.g. Pivotal Cloud Cache (PCC)) on platform. +but connecting those apps to managed data services (e.g. {cloudcache-name} (PCC)) on platform. There may be cases where you are unable to move your data management architecture for your applications entirely to the cloud. In those cases, SBDG supports a Hybrid Cloud Architecture, that is both an on-prem and off-prem arrangement. @@ -2036,10 +2036,10 @@ link:../index.html#cloudfoundry-geode[here]. [[spring-geode-samples-getting-started-summary]] == Summary -In this guide, we saw first-hand the power of Spring Boot for Apache Geode (SBDG) when building Apache Geode powered +In this guide, we saw first-hand the power of Spring Boot for {geode-name} (SBDG) when building {geode-name} powered Spring Boot applications. -Apache Geode can truly make your Spring Boot applications highly resilient to failures, highly available, performant +{geode-name} can truly make your Spring Boot applications highly resilient to failures, highly available, performant (i.e. high throughput and low latency), without sacrificing consistency, which is paramount to any data intensive application. @@ -2047,7 +2047,7 @@ SBDG handles a lot of low-level application concerns so you do not have to. You can remain on building the application to meet your customers' needs, collect feedback, iterate rapidly, and realize the value proposition sooner. -Indeed, our intended goal is to make developing Apache Geode applications with Spring, and Spring Boot in particular, +Indeed, our intended goal is to make developing {geode-name} applications with Spring, and Spring Boot in particular, a highly productive and enjoyable experience. We hope you enjoy! diff --git a/spring-geode-docs/src/docs/asciidoc/index-docinfo.xml b/spring-geode-docs/src/docs/asciidoc/index-docinfo.xml index 0f6097fe..2fe32e73 100644 --- a/spring-geode-docs/src/docs/asciidoc/index-docinfo.xml +++ b/spring-geode-docs/src/docs/asciidoc/index-docinfo.xml @@ -1,4 +1,4 @@ -Spring Boot for Apache Geode & Pivotal GemFire +Spring Boot for Apache Geode & VMware Tanzu GemFire {spring-boot-data-geode-version} 2020 diff --git a/spring-geode-docs/src/docs/asciidoc/index.adoc b/spring-geode-docs/src/docs/asciidoc/index.adoc index 51b3d0d2..3de64017 100644 --- a/spring-geode-docs/src/docs/asciidoc/index.adoc +++ b/spring-geode-docs/src/docs/asciidoc/index.adoc @@ -1,5 +1,5 @@ [[spring-boot-data-geode]] -= Spring Boot for Apache Geode & Pivotal GemFire Reference Guide += Spring Boot for Apache Geode & VMware Tanzu GemFire Reference Guide John Blum :revdate: {localdate} :revnumber: {version} @@ -19,6 +19,7 @@ John Blum :apache-geode-javadoc: https://geode.apache.org/releases/latest/javadoc :apache-geode-website: https://geode.apache.org/ :apache-geode-wiki: https://cwiki.apache.org/confluence/display/GEODE +:pivotal-cloudcache-name: VMware Tanzu GemFire for VMs :pivotal-cloudcache-version: {pivotal-cloudcache-doc-version} :pivotal-cloudcache-docs: https://docs.pivotal.io/p-cloud-cache/{pivotal-cloudcache-version} :pivotal-cloudcache-website: https://pivotal.io/pivotal-cloud-cache @@ -259,7 +260,3 @@ include::{include-dir}/cloudfoundry.adoc[] include::{include-dir}/docker.adoc[] include::{include-dir}/samples.adoc[] include::{include-dir}/appendix.adoc[] - - - - diff --git a/spring-geode-docs/src/main/java/org/springframework/geode/docs/example/app/locator/SpringBootApacheGeodeLocatorApplication.java b/spring-geode-docs/src/main/java/org/springframework/geode/docs/example/app/locator/SpringBootApacheGeodeLocatorApplication.java index a6855f30..a1581754 100644 --- a/spring-geode-docs/src/main/java/org/springframework/geode/docs/example/app/locator/SpringBootApacheGeodeLocatorApplication.java +++ b/spring-geode-docs/src/main/java/org/springframework/geode/docs/example/app/locator/SpringBootApacheGeodeLocatorApplication.java @@ -30,7 +30,7 @@ import org.springframework.geode.config.annotation.UseLocators; /** * The {@link SpringBootApacheGeodeLocatorApplication} class is a Spring Boot application that configures and bootstraps - * an Apache Geode or Pivotal GemFire {@link Locator} application JVM process. + * an Apache Geode {@link Locator} application JVM process. * * @author John Blum * @see org.apache.geode.distributed.Locator diff --git a/spring-geode-samples/boot/configuration/src/main/resources/application-security.properties b/spring-geode-samples/boot/configuration/src/main/resources/application-security.properties index 255c219a..cad17fb4 100644 --- a/spring-geode-samples/boot/configuration/src/main/resources/application-security.properties +++ b/spring-geode-samples/boot/configuration/src/main/resources/application-security.properties @@ -1,4 +1,4 @@ -# Security Configuration for Apache Geode/Pivotal GemFire using Spring Boot and Spring Data GemFire properties +# Security Configuration for Apache Geode using Spring Boot and Spring Data for Apache Geode properties spring.boot.data.gemfire.security.ssl.keystore.name=example-trusted-keystore.jks spring.data.gemfire.security.username=test diff --git a/spring-geode-samples/boot/configuration/src/main/resources/application.properties b/spring-geode-samples/boot/configuration/src/main/resources/application.properties index 626ba907..c6f7d76b 100644 --- a/spring-geode-samples/boot/configuration/src/main/resources/application.properties +++ b/spring-geode-samples/boot/configuration/src/main/resources/application.properties @@ -1,4 +1,4 @@ -# Configuration for Apache Geode/Pivotal GemFire using Spring Boot and Spring Data GemFire properties +# Configuration for Apache Geode using Spring Boot and Spring Data for Apache Geode properties spring.application.name=CustomerServiceApplication spring.data.gemfire.cache.log-level=error diff --git a/spring-geode/src/main/java/org/springframework/geode/cache/support/CacheWriterSupport.java b/spring-geode/src/main/java/org/springframework/geode/cache/support/CacheWriterSupport.java index 11f6cc73..55e91854 100644 --- a/spring-geode/src/main/java/org/springframework/geode/cache/support/CacheWriterSupport.java +++ b/spring-geode/src/main/java/org/springframework/geode/cache/support/CacheWriterSupport.java @@ -21,7 +21,7 @@ import org.apache.geode.cache.EntryEvent; import org.apache.geode.cache.RegionEvent; /** - * Class supporting the implementation of Apache Geode / Pivotal GemFire (PCC) {@link CacheWriter CacheWriters}. + * Class supporting the implementation of Apache Geode {@link CacheWriter CacheWriters}. * * @author John Blum * @see org.apache.geode.cache.CacheWriter diff --git a/spring-geode/src/main/java/org/springframework/geode/cache/support/RepositoryCacheLoaderWriterSupport.java b/spring-geode/src/main/java/org/springframework/geode/cache/support/RepositoryCacheLoaderWriterSupport.java index 73577487..12d7b2d8 100644 --- a/spring-geode/src/main/java/org/springframework/geode/cache/support/RepositoryCacheLoaderWriterSupport.java +++ b/spring-geode/src/main/java/org/springframework/geode/cache/support/RepositoryCacheLoaderWriterSupport.java @@ -34,7 +34,7 @@ import org.springframework.lang.Nullable; import org.springframework.util.Assert; /** - * Abstract base class supporting the implementation of Apache Geode / Pivotal GemFire {@link CacheLoader CacheLoaders} + * Abstract base class supporting the implementation of Apache Geode {@link CacheLoader CacheLoaders} * and {@link CacheWriter CacheWriters} backed by Spring Data {@link Repository Repositories}. * * @author John Blum diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterAvailableConfiguration.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterAvailableConfiguration.java index fb38ee0d..8a6bc548 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterAvailableConfiguration.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterAvailableConfiguration.java @@ -24,7 +24,7 @@ import org.springframework.data.gemfire.config.annotation.EnableClusterConfigura /** * The {@link ClusterAvailableConfiguration} class is a Spring {@link Configuration @Configuration} class that enables - * configuration when an Apache Geode or Pivotal GemFire cluster of servers are available. + * configuration when an Apache Geode cluster of servers are available. * * @author John Blum * @see org.springframework.boot.autoconfigure.condition.AnyNestedCondition diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterNotAvailableConfiguration.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterNotAvailableConfiguration.java index 785819bc..cb49a3e6 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterNotAvailableConfiguration.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/ClusterNotAvailableConfiguration.java @@ -39,7 +39,7 @@ import org.springframework.lang.Nullable; /** * The {@link ClusterNotAvailableConfiguration} class is a Spring {@link Configuration @Configuration} class that - * enables configuration when an Apache Geode or Pivotal GemFire cluster of servers is not available. + * enables configuration when an Apache Geode cluster of servers is not available. * * @author John Blum * @see org.springframework.beans.factory.config.BeanPostProcessor diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableClusterAware.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableClusterAware.java index b583ee7c..83a44a3e 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableClusterAware.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableClusterAware.java @@ -25,9 +25,8 @@ import java.lang.annotation.Target; import org.springframework.context.annotation.Import; /** - * The {@link EnableClusterAware} helps an Spring Boot application using Apache Geode (or Pivotal GemFire - * / Pivotal Cloud Cache (PCC)) decide whether it needs to operate in {@literal local-only mode} - * or {@literal client/server}. + * The {@link EnableClusterAware} helps an Spring Boot application using Apache Geode decide whether it needs to operate + * in {@literal local-only mode} or {@literal client/server}. * * @author John Blum * @see java.lang.annotation.Annotation diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableSecurityManager.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableSecurityManager.java index 8def12ac..577a1c49 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableSecurityManager.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableSecurityManager.java @@ -26,7 +26,7 @@ import java.lang.annotation.Target; import org.springframework.context.annotation.Import; /** - * Spring {@link Annotation} to enable Apache Geode or Pivotal GemFire (PCC) Security (Auth). + * Spring {@link Annotation} to enable Apache Geode Security (Auth). * * @author John Blum * @see java.lang.annotation.Annotation diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableSecurityManagerProxy.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableSecurityManagerProxy.java index 3559f18b..df8a890b 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableSecurityManagerProxy.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/EnableSecurityManagerProxy.java @@ -26,7 +26,7 @@ import java.lang.annotation.Target; import org.springframework.context.annotation.Import; /** - * Spring {@link Annotation} to enable Apache Geode or Pivotal GemFire (PCC) Security (Auth) through proxying. + * Spring {@link Annotation} to enable Apache Geode Security (Auth) through proxying. * * @author John Blum * @see java.lang.annotation.Annotation diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/GroupsConfiguration.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/GroupsConfiguration.java index 3d422818..d5629e6a 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/GroupsConfiguration.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/GroupsConfiguration.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.config.annotation; import java.lang.annotation.Annotation; @@ -21,6 +20,7 @@ import java.util.Optional; import org.apache.geode.cache.Cache; import org.apache.geode.cache.client.ClientCache; + import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.ImportAware; @@ -34,9 +34,8 @@ import org.springframework.util.StringUtils; /** * The {@link GroupsConfiguration} class is a Spring {@link Configuration} class used to configure the {@literal groups} - * in which is member belongs in an Apache Geode/Pivotal GemFire distributed system, whether the member - * is a {@link ClientCache} in a client/server topology or a {@link Cache peer Cache} in a cluster - * using the P2P topology. + * in which is member belongs in an Apache Geode distributed system, whether the member is a {@link ClientCache} + * in a client/server topology or a {@link Cache peer Cache} in a cluster using the P2P topology. * * @author John Blum * @see org.apache.geode.cache.Cache diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/LocatorsConfiguration.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/LocatorsConfiguration.java index 5390058b..ebc0e2bf 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/LocatorsConfiguration.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/LocatorsConfiguration.java @@ -21,9 +21,6 @@ import java.util.Properties; import org.apache.geode.cache.Cache; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.ImportAware; @@ -35,10 +32,13 @@ import org.springframework.data.gemfire.config.annotation.PeerCacheConfigurer; import org.springframework.data.gemfire.config.annotation.support.AbstractAnnotationConfigSupport; import org.springframework.util.StringUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + /** * The {@link LocatorsConfiguration} class is a Spring {@link Configuration} class used to configure Apache Geode - * or Pivotal GemFire's {@literal locators} and/or {@literal remote-locators} properties used by a - * {@link Cache peer Cache member} to join a cluster of servers when using the P2P topology. + * {@literal locators} and/or {@literal remote-locators} properties used by a {@link Cache peer Cache member} + * to join a cluster of servers when using the P2P topology. * * The {@literal remote-locators} property is used to configure the Locators that a cluster will use in order to * connect to a remote site in a multi-site (WAN) topology configuration. To use Locators in a WAN configuration, diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/MemberNameConfiguration.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/MemberNameConfiguration.java index 6aace8ef..3cf7002d 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/MemberNameConfiguration.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/MemberNameConfiguration.java @@ -38,10 +38,9 @@ import org.springframework.data.gemfire.config.annotation.support.AbstractAnnota import org.springframework.util.StringUtils; /** - * The {@link MemberNameConfiguration} class is a Spring {@link Configuration} class used to configure - * an Apache Geode or Pivotal GemFire's member name in the distributed system, whether the member - * is a {@link ClientCache client} in the client/server topology or a {@link Cache peer} in a cluster - * using the P2P topology. + * The {@link MemberNameConfiguration} class is a Spring {@link Configuration} class used to configure an Apache Geode's + * member name in the distributed system, whether the member is a {@link ClientCache client} in the client/server + * topology or a {@link Cache peer} in a cluster using the P2P topology. * * @author John Blum * @see org.apache.geode.cache.Cache diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseDistributedSystemId.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseDistributedSystemId.java index 499f0961..a53440ac 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseDistributedSystemId.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseDistributedSystemId.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.config.annotation; import java.lang.annotation.Documented; @@ -25,12 +24,13 @@ import java.lang.annotation.Target; import org.apache.geode.cache.Cache; import org.apache.geode.cache.client.ClientCache; + import org.springframework.context.annotation.Import; import org.springframework.core.annotation.AliasFor; /** * The {@link UseDistributedSystemId} annotation configures the {@literal distributed-system-id} property - * of a {@link Cache peer Cache member} in an Apache Geode/Pivotal GemFire P2P topology. + * of a {@link Cache peer Cache member} in an Apache Geode P2P topology. * * This configuration annotation is only applicable on {@link Cache peer Cache members} * and has no effect on {@link ClientCache} instances. diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseGroups.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseGroups.java index 6ecb18d2..dd7ec684 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseGroups.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseGroups.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.config.annotation; import java.lang.annotation.Documented; @@ -25,12 +24,13 @@ import java.lang.annotation.Target; import org.apache.geode.cache.Cache; import org.apache.geode.cache.client.ClientCache; + import org.springframework.context.annotation.Import; import org.springframework.core.annotation.AliasFor; /** * The {@link UseGroups} annotation configures the groups in which the member belongs in an Apache Geode - * or Pivotal GemFire distributed system, whether the member is a {@link ClientCache} in a client/server topology + * distributed system, whether the member is a {@link ClientCache} in a client/server topology * or a {@link Cache peer Cache} in a cluster using the P2P topology. * * @author John Blum diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseLocators.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseLocators.java index b4ee5e07..3723cc3f 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseLocators.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseLocators.java @@ -32,7 +32,7 @@ import org.springframework.core.annotation.AliasFor; /** * The {@link UseLocators} annotation configures the {@literal locators} and/or {@literal remote-locators} - * Apache Geode/Pivotal GemFire properties used by a {@link Cache peer Cache member} to join a cluster of servers + * Apache Geode properties used by a {@link Cache peer Cache member} to join a cluster of servers * when using the P2P topology as well as when configuring the multi-site, WAN topology. * * @author John Blum diff --git a/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseMemberName.java b/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseMemberName.java index 72090139..c8aed087 100644 --- a/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseMemberName.java +++ b/spring-geode/src/main/java/org/springframework/geode/config/annotation/UseMemberName.java @@ -30,8 +30,8 @@ import org.springframework.core.annotation.AliasFor; /** * The {@link UseMemberName} annotation configures the {@literal name} of the member in the Apache Geode - * or Pivotal GemFire distributed system, whether the member is a {@link ClientCache client} in - * the client/server topology or a {@link Cache peer Cache member} in the cluster using the P2P topology. + * distributed system, whether the member is a {@link ClientCache client} in the client/server topology + * or a {@link Cache peer Cache member} in the cluster using the P2P topology. * * @author John Blum * @see java.lang.annotation.Documented @@ -53,7 +53,7 @@ import org.springframework.core.annotation.AliasFor; public @interface UseMemberName { /** - * Alias for the {@link String name} of the Apache Geode/Pivotal GemFire distributed system member. + * Alias for the {@link String name} of the Apache Geode distributed system member. * * @see #value() */ @@ -61,7 +61,7 @@ public @interface UseMemberName { String name() default ""; /** - * {@link String Name} used for the Apache Geode/Pivotal GemFire distributed system member. + * {@link String Name} used for the Apache Geode distributed system member. * * @see #name() */ diff --git a/spring-geode/src/main/java/org/springframework/geode/context/annotation/RefreshableAnnotationConfigApplicationContext.java b/spring-geode/src/main/java/org/springframework/geode/context/annotation/RefreshableAnnotationConfigApplicationContext.java index d44d2cf2..5a1820bb 100644 --- a/spring-geode/src/main/java/org/springframework/geode/context/annotation/RefreshableAnnotationConfigApplicationContext.java +++ b/spring-geode/src/main/java/org/springframework/geode/context/annotation/RefreshableAnnotationConfigApplicationContext.java @@ -53,10 +53,10 @@ import org.slf4j.LoggerFactory; * providing the ability to reload/refresh the context at some point later during runtime. * * DISCLAIMER: Currently, this {@link ApplicationContext} implementation (and extension) is being used exclusively for - * testing and experimental (R&D) purposes. It was designed around Apache Geode & Pivotal GemFire's forced-disconnect - * / auto-reconnect functionality, providing support for this behavior inside a Spring context. Specifically, this - * concern is only applicable when using Spring Boot to configure and bootstrap Apache Geode or Pivotal GemFire peer - * member {@link org.apache.geode.cache.Cache} applications, such as when annotating your Spring Boot application with + * testing and experimental (R&D) purposes. It was designed around Apache Geode forced-disconnect / auto-reconnect + * functionality, providing support for this behavior inside a Spring context. Specifically, this concern is only + * applicable when using Spring Boot to configure and bootstrap Apache Geode peer member + * {@link org.apache.geode.cache.Cache} applications, such as when annotating your Spring Boot application with * SDG's {@link PeerCacheApplication} annotation. This {@link ApplicationContext} implementation is not recommended for * use in Production Systems/Applications (yet). * diff --git a/spring-geode/src/main/java/org/springframework/geode/core/env/support/CloudCacheService.java b/spring-geode/src/main/java/org/springframework/geode/core/env/support/CloudCacheService.java index fa75ce6e..3bed7e92 100644 --- a/spring-geode/src/main/java/org/springframework/geode/core/env/support/CloudCacheService.java +++ b/spring-geode/src/main/java/org/springframework/geode/core/env/support/CloudCacheService.java @@ -69,10 +69,10 @@ public class CloudCacheService extends Service { } /** - * Returns an {@link Optional} Gfsh {@link URL}, if configured, used to connect to Pivotal GemFire's + * Returns an {@link Optional} Gfsh {@link URL}, if configured, used to connect to Apache Geode's * Management REST API (service). * - * @return an {@link Optional} Gfsh {@link URL} used to connect to Pivotal GemFire's Management REST API (service). + * @return an {@link Optional} Gfsh {@link URL} used to connect to Apache Geode's Management REST API (service). * @see #withGfshUrl(URL) * @see java.util.Optional * @see java.net.URL @@ -82,11 +82,11 @@ public class CloudCacheService extends Service { } /** - * Returns an {@link Optional} {@link String} containing the list of Pivotal GemFire Locator network endpoints. + * Returns an {@link Optional} {@link String} containing the list of Apache Geode Locator network endpoints. * * The format of the {@link String}, if present, is {@literal host1[port1],host2[port2], ...,hostN[portN]}. * - * @return an {@link Optional} {@link String} containing the list of Pivotal GemFire Locator network endpoints. + * @return an {@link Optional} {@link String} containing the list of Apache Geode Locator network endpoints. * @see #withLocators(String) */ public Optional getLocators() { @@ -96,11 +96,11 @@ public class CloudCacheService extends Service { } /** - * Returns a {@link List} of Pivotal GemFire Locator network endpoints. + * Returns a {@link List} of Apache Geode Locator network endpoints. * * Returns an {@link Collections#emptyList() empty List} if no Locators were configured. * - * @return a {@link List} of Pivotal GemFire Locator network endpoints. + * @return a {@link List} of Apache Geode Locator network endpoints. * @see #getLocators() */ public List getLocatorList() { @@ -121,10 +121,10 @@ public class CloudCacheService extends Service { } /** - * Builder method used to configure the Gfsh {@link URL} to connect to the Pivotal GemFire + * Builder method used to configure the Gfsh {@link URL} to connect to the Apache Geode * Management REST API (service). * - * @param gfshUrl {@link URL} used to connect to the Pivotal GemFire Management REST API (service). + * @param gfshUrl {@link URL} used to connect to the Apache Geode Management REST API (service). * @return this {@link CloudCacheService}. * @see #getGfshUrl() */ diff --git a/spring-geode/src/main/java/org/springframework/geode/function/config/GemFireFunctionExecutionAutoConfigurationRegistrar.java b/spring-geode/src/main/java/org/springframework/geode/function/config/GemFireFunctionExecutionAutoConfigurationRegistrar.java index 11bcc6c5..4ec7b819 100644 --- a/spring-geode/src/main/java/org/springframework/geode/function/config/GemFireFunctionExecutionAutoConfigurationRegistrar.java +++ b/spring-geode/src/main/java/org/springframework/geode/function/config/GemFireFunctionExecutionAutoConfigurationRegistrar.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.function.config; import org.apache.geode.cache.execute.Execution; @@ -23,8 +22,7 @@ import org.springframework.data.gemfire.function.config.EnableGemfireFunctionExe /** * The {@link GemFireFunctionExecutionAutoConfigurationRegistrar} class is a Spring {@link ImportBeanDefinitionRegistrar} - * used to register SDG POJO interfaces defining Apache Geode/Pivotal GemFire - * {@link Function} {@link Execution Executions} + * used to register SDG POJO interfaces defining Apache Geode {@link Function} {@link Execution Executions}. * * @author John Blum * @see org.apache.geode.cache.execute.Execution diff --git a/spring-geode/src/main/java/org/springframework/geode/security/support/SecurityManagerProxy.java b/spring-geode/src/main/java/org/springframework/geode/security/support/SecurityManagerProxy.java index 72ed2e9a..949e9e4d 100644 --- a/spring-geode/src/main/java/org/springframework/geode/security/support/SecurityManagerProxy.java +++ b/spring-geode/src/main/java/org/springframework/geode/security/support/SecurityManagerProxy.java @@ -21,6 +21,7 @@ import java.util.concurrent.atomic.AtomicReference; import org.apache.geode.security.AuthenticationFailedException; import org.apache.geode.security.ResourcePermission; + import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; @@ -35,7 +36,7 @@ import org.springframework.util.Assert; * which is registered as a managed bean in a Spring context. * * The idea behind this {@link org.apache.geode.security.SecurityManager} is to enable users to be able to configure - * and manage the {@code SecurityManager} as a Spring bean. However, Apache Geode/Pivotal GemFire require + * and manage the {@code SecurityManager} as a Spring bean. However, Apache Geode requires * the {@link org.apache.geode.security.SecurityManager} to be configured using a System property when launching * Apache Geode Servers with Gfsh, which makes it difficult to "manage" the {@code SecurityManager} instance. * @@ -82,8 +83,7 @@ public class SecurityManagerProxy extends LazyWiringDeclarableSupport private org.apache.geode.security.SecurityManager securityManager; /** - * Returns a reference to the single {@link SecurityManagerProxy} instance configured by - * Apache Geode/Pivotal GemFire in startup. + * Returns a reference to the single {@link SecurityManagerProxy} instance configured by Apache Geode in startup. * * @return a reference to the single {@link SecurityManagerProxy} instance. */ @@ -176,6 +176,6 @@ public class SecurityManagerProxy extends LazyWiringDeclarableSupport protected BeanFactory locateBeanFactory() { return Optional.ofNullable(this.beanFactory) - .orElseGet(() -> super.locateBeanFactory()); + .orElseGet(super::locateBeanFactory); } } diff --git a/spring-geode/src/main/java/org/springframework/geode/security/support/SecurityManagerSupport.java b/spring-geode/src/main/java/org/springframework/geode/security/support/SecurityManagerSupport.java index 033ffddf..48051e48 100644 --- a/spring-geode/src/main/java/org/springframework/geode/security/support/SecurityManagerSupport.java +++ b/spring-geode/src/main/java/org/springframework/geode/security/support/SecurityManagerSupport.java @@ -13,7 +13,6 @@ * or implied. See the License for the specific language governing * permissions and limitations under the License. */ - package org.springframework.geode.security.support; import java.util.Properties; @@ -22,9 +21,9 @@ import org.apache.geode.security.AuthenticationFailedException; import org.apache.geode.security.ResourcePermission; /** - * {@link SecurityManagerSupport} is an abstract base class implementing Apache Geode/Pivotal GemFire's - * {@link org.apache.geode.security.SecurityManager} interface, providing default implementations of the - * {@literal SecurityManager's} auth methods. + * {@link SecurityManagerSupport} is an abstract base class implementing Apache Geode + * {@link org.apache.geode.security.SecurityManager} interface, providing default implementations + * of the {@literal SecurityManager's} auth methods. * * @author John Blum * @see org.apache.geode.security.SecurityManager diff --git a/spring-geode/src/main/resources/changelog.txt b/spring-geode/src/main/resources/changelog.txt index 599f1d0e..4b34bc28 100644 --- a/spring-geode/src/main/resources/changelog.txt +++ b/spring-geode/src/main/resources/changelog.txt @@ -12,11 +12,11 @@ and consistently. * Includes a new spring-geode-bom module creating a Maven BOM to manage the SBDG module dependency versions in a collective and consistent way. Resolves https://github.com/spring-projects/spring-boot-data-geode/issues/93. -* Revises (Edits) the chapter on "Caching with Apache Geode & Pivotal GemFire". +* Revises (Edits) the chapter on "Caching with Apache Geode & VMware Tanzu GemFire". * Upgrades to Spring Boot 2.3.3.RELEASE. * Upgrades to Spring Data Neumann-SR3. -* Upgrades to Spring Data for Apache Geode & VMware/Pivotal GemFire 2.3.3.RELEASE. -* Upgrades to Spring Test for Apache Geode & VMware/Pivotal GemFire 0.0.18.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.3.3.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.18.RELEASE. * Upgrades to Spring Build Conventions Gradle Plugin 0.0.34.RELEASE. * Upgrades to Byte Buddy 1.10.14. * Upgrades to Gradle 6.6. @@ -140,27 +140,27 @@ Resolves https://github.com/spring-projects/spring-boot-data-geode/issues/86. * Upgrades to Gradle 6.5. * Upgrades to Spring Build Conventions Gradle Plugin 0.0.32.RELEASE. * Upgrades to Spring Boot 2.3.0.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.3.0.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.3.0.RELEASE. * Upgrades to Spring Data Release Train Neumann-RELEASE. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.3.0.RELEASE +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.3.0.RELEASE * Upgrades to Spring Session BOM Dragonfruit-RELEASE. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.16.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.16.RELEASE. * Upgrades to Testcontainers 1.14.3. Changes in version 1.2.7.RELEASE (2020-05-19) --------------------------------------------- Aligns SBDG with the latest versions of Spring Framework, Spring Boot, Spring Data -and Spring Session for Apache Geode & Pivotal GemFire. +and Spring Session for Apache Geode & VMware Tanzu GemFire. * Asserts the auto-configuration of PDX when no PDX configuration is defined by the user, when PDX configuration is customized with SDG properties and when the user manually configures PDX, thereby overriding auto-configuration. * Upgrades to Spring Framework 5.2.6.RELEASE. * Upgrades to Spring Boot 2.2.7.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.2.7.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.2.7.RELEASE. * Upgrades to Spring Data Release Train Moore-SR7. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.2.4.RELEASE. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.14.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.4.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.14.RELEASE. * Upgrades to Byte Buddy 1.10.10. * Upgrades to Gradle 6.4.1. * Upgrades to Testcontainers 1.14.1. @@ -169,13 +169,13 @@ customized with SDG properties and when the user manually configures PDX, thereb Changes in version 1.1.7.RELEASE (2020-05-18) --------------------------------------------- Aligns SBDG with the latest versions of Spring Framework, Spring Boot, Spring Data -and Spring Session for Apache Geode & Pivotal GemFire. +and Spring Session for Apache Geode & VMware Tanzu GemFire. * Upgrades to Spring Framework 5.1.15.RELEASE. * Upgrades to Spring Boot 2.1.14.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.1.17.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.1.17.RELEASE. * Upgrades to Spring Data Release Train Lovelace-SR17. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.1.10.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.10.RELEASE. * Upgrades to Spring Session BOM Bean-SR10. * Upgrades to Byte Buddy 1.10.10. * Upgrades to Mockito 3.3.3. @@ -194,49 +194,49 @@ public API even easier and more reliable to use, and application friendly. * Upgrades to Byte Buddy 1.10.10. * Upgrades to Spring Framework 5.2.6.RELEASE. * Upgrades to Spring Boot 2.3.0.RC1. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire (SDG) 2.3.0.RC2. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire (SDG) 2.3.0.RC2. * Upgrades to Spring Data Release Train Neumann-RC2. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire (STDG) 0.0.15.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire (STDG) 0.0.15.RELEASE. * Upgrades Testcontainers to 1.14.1. Changes in version 1.3.0.M4 (2020-04-19) ---------------------------------------- Upgrades SBDG to Spring Boot 2.3.0.M4. Aligns with Spring Framework 5.2.5.RELEASE, Spring Data Neumann-RC1, -Spring Session for Apache Geode & Pivotal GemFire (SSDG) 2.3.0.RC2, Spring Test for Apache Geode -& Pivotal GemFire (STDG) 0.0.14.RELEASE. +Spring Session for Apache Geode & VMware Tanzu GemFire (SSDG) 2.3.0.RC2, Spring Test for Apache Geode +& VMware Tanzu GemFire (STDG) 0.0.14.RELEASE. -* Adds new Sample for Multi-Site Caching with Spring's Cache Abstraction and Apache Geode (Pivotal GemFire) Multi-site +* Adds new Sample for Multi-Site Caching with Spring's Cache Abstraction and Apache Geode (VMware Tanzu GemFire) Multi-site WAN Gateway configuration. Resolves https://github.com/spring-projects/spring-boot-data-geode/issues/80. * Adds support for Geode Properties (gemfire.properties) declared in Spring Boot application.properties. Resolves https://github.com/spring-projects/spring-boot-data-geode/issues/79. * Upgrades to Apache Geode 1.12.0. * Upgrades to Byte Buddy 1.10.9. -* Upgrades to Pivotal GemFire 9.10.0. +* Upgrades to VMware Tanzu GemFire 9.10.0. * Upgrades to Spring Framework 5.2.5.RELEASE. * Upgrades to Spring Boot 2.3.0.M4. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire (SDG) 2.3.0.RC1. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire (SDG) 2.3.0.RC1. * Upgrades to Spring Data Release Train Neumann-RC1. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire (SSDG) 2.3.0.RC2. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire (SSDG) 2.3.0.RC2. * Upgrades to Spring Session BOM Dragonfruit-RC2. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire (STDG) 0.0.14.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire (STDG) 0.0.14.RELEASE. * Upgrades Testcontainers to 1.14.0. Changes in version 1.2.6.RELEASE (2020-03-27) --------------------------------------------- Aligns SBDG with Spring Boot 2.2.6.RELEASE, Spring Framework 5.2.5.RELEASE, Spring Data Release Train Moore-SR6, -Spring Session Corn-SR2, Spring Test for Apache Geode & Pivotal GemFire 0.0.13.RELEASE, Apache Geode 1.9.2, -and Pivotal GemFire 9.8.7. +Spring Session Corn-SR2, Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.13.RELEASE, Apache Geode 1.9.2, +and VMware Tanzu GemFire 9.8.7. * Fix SSL auto-configuration when TLS is enabled to properly configure the SSL default context; See https://github.com/spring-projects/spring-boot-data-geode/issues/77. * Upgrades to Gradle 6.2. * Upgrades to Mockito 3.3.3. -* Upgrades to Pivotal GemFire 9.8.7. +* Upgrades to VMware Tanzu GemFire 9.8.7. * Upgrades to Spring Framework 5.2.5.RELEASE. * Upgrades to Spring Boot 2.2.6.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.2.6.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.2.6.RELEASE. * Upgrades to Spring Data Release Train Moore-SR6. * Upgrades to Spring Session BOM Corn-SR2. @@ -244,8 +244,8 @@ See https://github.com/spring-projects/spring-boot-data-geode/issues/77. Changes in version 1.3.0.M3 (2020-03-20) ---------------------------------------- Upgrades SBDG to Spring Boot 2.3.0.M3. Aligns with Spring Framework 5.2.4.RELEASE, Spring Data Neumann-M4, -Spring Session for Apache Geode & Pivotal GemFire (SSDG) 2.3.0.RC1, Spring Test for Apache Geode -& Pivotal GemFire (STDG) 0.0.13.RELEASE. +Spring Session for Apache Geode & VMware Tanzu GemFire (SSDG) 2.3.0.RC1, Spring Test for Apache Geode +& VMware Tanzu GemFire (STDG) 0.0.13.RELEASE. * Adds Maven POM file(s) for SBDG Samples in order to build and run the Sample Code independently from the main project Gradle build. Resolves (partly) https://github.com/spring-projects/spring-boot-data-geode/issues/75. @@ -256,23 +256,23 @@ Resolves https://github.com/spring-projects/spring-boot-data-geode/issues/77. * Upgrades to Mockito 3.3.3. * Upgrades to Spring Framework 5.2.4.RELEASE. * Upgrades to Spring Boot 2.3.0.M3. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.3.0.M4. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.3.0.M4. * Upgrades to Spring Data Release Train Neumann-M4. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.3.0.RC1. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.13.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.3.0.RC1. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.13.RELEASE. * Upgrades to Testcontainers 1.13.0. Changes in version 1.2.5.RELEASE (2020-03-04) --------------------------------------------- Aligns SBDG with Spring Framework 5.2.4.RELEASE, Spring Boot 2.2.5.RELEASE, Spring Data Moore-SR5 -and Spring Session for Apache Geode & Pivotal GemFire 2.2.3.RELEASE. +and Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.3.RELEASE. * Upgrades to Spring Framework 5.2.4.RELEASE. * Upgrades to Spring Boot 2.2.5.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.2.5.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.2.5.RELEASE. * Upgrades to Spring Data Release Train Moore-SR5. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.2.3.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.3.RELEASE. * Upgrades to Spring Session BOM Corn-SR1 * Upgrades to Mockito 3.3.0. @@ -280,13 +280,13 @@ and Spring Session for Apache Geode & Pivotal GemFire 2.2.3.RELEASE. Changes in version 1.1.6.RELEASE (2020-03-04) --------------------------------------------- Aligns SBDG with Spring Framework 5.1.14.RELEASE, Spring Boot 2.1.13.RELEASE, Spring Data Lovelace-SR16 -and Spring Session for Apache Geode & Pivotal GemFire 2.1.9.RELEASE. +and Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.9.RELEASE. * Upgrades to Spring Framework 5.1.14.RELEASE. * Upgrades to Spring Boot 2.1.13.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.1.16.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.1.16.RELEASE. * Upgrades to Spring Data Release Train Lovelace-SR16. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.1.9.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.9.RELEASE. * Upgrades to Spring Session BOM Bean-SR9. * Upgrades to Byte Buddy 1.10.8. * Upgrades to Mockito 3.3.0. @@ -296,40 +296,40 @@ and Spring Session for Apache Geode & Pivotal GemFire 2.1.9.RELEASE. Changes in version 1.3.0.M2 (2020-02-20) ---------------------------------------- Aligns SBDG with Spring Boot 2.3.0.M2. Upgrades to Spring Data Neumann-M3, Spring Session for Apache Geode -& Pivotal GemFire 2.3.0.M2 and Spring Test for Apache Geode & Pivotal GemFire 0.0.13.RELEASE. Adds new +& VMware Tanzu GemFire 2.3.0.M2 and Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.13.RELEASE. Adds new spring-geode-starter-logging module to configure Apache Geode logging. * Upgrades to Spring Boot 2.3.0.M2. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.3.0.M3. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.3.0.M3. * Upgrades to Spring Data Release Train Neumann-M3. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.3.0.M2. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.3.0.M2. * Upgrades to Spring Session BOM Dragonfruit-M2. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.13.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.13.RELEASE. * Upgrades to Byte Buddy 1.10.7. * Upgrades to FreeFair Lombok Gradle Plugin 5.0.0-rc2. * Upgrades to Testcontainers 1.12.5. * Began removing uses of internal Apache Geode APIs from SBDG; Resolves (partly) https://github.com/spring-projects/spring-boot-data-geode/issues/70. -* Adds a new spring-geode-starter-logging module to configure and control Apache Geode & Pivotal GemFire logging; +* Adds a new spring-geode-starter-logging module to configure and control Apache Geode & VMware Tanzu GemFire logging; Resolves https://github.com/spring-projects/spring-boot-data-geode/issues/73. -* Adds documentation on how to enable Apache Geode & Pivotal GemFire logging with Spring Boot; +* Adds documentation on how to enable Apache Geode & VMware Tanzu GemFire logging with Spring Boot; Resolves https://github.com/spring-projects/spring-boot-data-geode/issues/71. -* Adds documentation on how to configure and bootstrap Apache Geode/Pivotal GemFire Managers with Spring Boot; +* Adds documentation on how to configure and bootstrap Apache Geode/VMware Tanzu GemFire Managers with Spring Boot; Resolves https://github.com/spring-projects/spring-boot-data-geode/issues/72. Changes in version 1.3.0.M1 (2020-01-24) ---------------------------------------- Aligns SBDG with Spring Framework 5.2.3.RELEASE, Spring Boot 2.3.0.M1, Spring Data Neumann-M2 -and Spring Session for Apache Geode & Pivotal GemFire 2.3.0.M1 +and Spring Session for Apache Geode & VMware Tanzu GemFire 2.3.0.M1 * Upgrades to Spring Framework 5.2.3.RELEASE. * Upgrades to Spring Boot 2.3.0.M1 -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.3.0.M2 +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.3.0.M2 * Upgrades to Spring Data Release Train Nuemann-M2. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.3.0.M1 +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.3.0.M1 * Upgrades to Spring Session BOM Corn-RELEASE. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.13.NEUMANN-BUILD-SNAPSHOT. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.13.NEUMANN-BUILD-SNAPSHOT. * Upgrades to ByteBuddy 1.10.5 * Upgrades to Mockito 3.2.4. * Removes some uses of internal Apache Geode APIs to resolve gh-70. @@ -345,15 +345,15 @@ Aligns SBDG with Spring Boot 2.2.4.RELEASE. Changes in version 1.2.3.RELEASE (2020-01-24) --------------------------------------------- Aligns SBDG with Spring Framework 5.2.3.RELEASE, Spring Boot 2.2.3.RELEASE, Spring Data Moore-SR4 -and Spring Session for Apache Geode & Pivotal GemFire 2.2.2.RELEASE. +and Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.2.RELEASE. * Upgrades to Spring Framework 5.2.3.RELEASE. * Upgrades to Spring Boot 2.2.3.RELEASE -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.2.4.RELEASE +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.2.4.RELEASE * Upgrades to Spring Data Release Train Moore-SR4. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.2.2.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.2.RELEASE. * Upgrades to Spring Session BOM Corn-RELEASE. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.12.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.12.RELEASE. * Upgrades to Mockito 3.2.4. * Removes some uses of internal Apache Geode APIs to resolve gh-70. @@ -361,13 +361,13 @@ and Spring Session for Apache Geode & Pivotal GemFire 2.2.2.RELEASE. Changes in version 1.1.5.RELEASE (2020-01-24) --------------------------------------------- Aligns SBDG with Spring Framework 5.1.13.RELEASE, Spring Boot 2.1.12.RELEASE, Spring Data Lovelace-SR15 -and Spring Session for Apache Geode & Pivotal GemFire 2.1.8.RELEASE. +and Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.8.RELEASE. * Upgrades to Spring Framework 5.1.13.RELEASE. * Upgrades to Spring Boot 2.1.12.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.1.15.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.1.15.RELEASE. * Upgrades to Spring Data Release Train Lovelace-SR15. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.1.8.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.8.RELEASE. * Upgrades to Spring Session BOM Bean-SR8. * Upgrades to Mockito 3.2.4. @@ -375,17 +375,17 @@ and Spring Session for Apache Geode & Pivotal GemFire 2.1.8.RELEASE. Changes in version 1.2.2.RELEASE (2019-12-11) --------------------------------------------- Aligns SBDG with Spring Framework 5.2.2.RELEASE, Spring Boot 2.2.2.RELEASE, Spring Data Moore-SR3 -and Spring Session for Apache Geode & Pivotal GemFire 2.2.1.RELEASE. +and Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.1.RELEASE. * Improves EnableClusterAware configuration logic to identify CacheTypeAwareRegionFactoryBeans. * Configures the Pool used by Spring Session to the DEFAULT Pool. * Upgrades to Spring Framework 5.2.2.RELEASE. * Upgrades to Spring Boot 2.2.2.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.2.3.RELEASE +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.2.3.RELEASE * Upgrades to Spring Data Release Train Moore-SR3. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.2.1.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.1.RELEASE. * Upgrades to Spring Session BOM Corn-RELEASE. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.11.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.11.RELEASE. * Upgrades to Mockito 3.2.0. * Upgrades to TestContainers 1.12.3. @@ -393,13 +393,13 @@ and Spring Session for Apache Geode & Pivotal GemFire 2.2.1.RELEASE. Changes in version 1.1.4.RELEASE (2019-12-11) --------------------------------------------- Aligns SBDG with Spring Framework 5.1.12.RELEASE, Spring Boot 2.1.11.RELEASE, Spring Data Lovelace-SR14 -and Spring Session for Apache Geode & Pivotal GemFire 2.1.7.RELEASE. +and Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.7.RELEASE. * Upgrades to Spring Framework 5.1.12.RELEASE. * Upgrades to Spring Boot 2.1.11.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.1.14.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.1.14.RELEASE. * Upgrades to Spring Data Release Train Lovelace-SR14. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.1.7.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.7.RELEASE. * Upgrades to Spring Session BOM Bean-SR8. * Upgrades to Gradle Wrapper (gradlew) 5.6.4. * Upgrades to Mockito 3.2.0. @@ -415,7 +415,7 @@ coverage around cluster configuration metadata push from client to server. Geode's cluster configuration push from client to server using REST over HTTP. * Upgrades to Spring Framework 5.2.1.RELEASE. * Upgrades to Spring Boot 2.2.1.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.2.1.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.2.1.RELEASE. * Upgrades to Spring Data Release Train Moore-SR1. @@ -428,28 +428,28 @@ test coverage around cluster configuration metadata push from client to server. Spring Data Geode's cluster configuration push from client to server over HTTP/REST. * Upgrades to Spring Framework 5.1.11.RELEASE. * Upgrades to Spring Boot 2.1.10.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.1.12.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.1.12.RELEASE. * Upgrades to Spring Data Release Train Lovelace-SR12. Changes in version 1.2.0.RELEASE (2019-10-18) --------------------------------------------- Tidies up the SBDG project for the 1.2 GA release. Removes the spring-cloudcache-starter* modules and then clarifies -in documentation about switching from Apache Geode to Pivotal GemFire bits, even in the context of Pivotal Platform +in documentation about switching from Apache Geode to VMware Tanzu GemFire bits, even in the context of Pivotal Platform (PCF) using Pivotal Cloud Cache (PCC). Adds auto-configuration support for TLS in PCF when using PCC. * Adds auto-configuration support to detect when TLS is enabled in PCF when using PCC and then configures SSL between the client and servers in a PCC cluster using the default SSL context provided via the JRE. See https://github.com/spring-projects/spring-boot-data-geode/issues/61. -* Edits the documentation in the Appendix on switching between Apache Geode and Pivotal GemFire or Pivotal Cloud Cache +* Edits the documentation in the Appendix on switching between Apache Geode and VMware Tanzu GemFire or Pivotal Cloud Cache (PCC) with additional details on the required Pivotal Commercial Repository declaration as well ass the server declaration containing user credentials required to authenticate with the repo in ~/.m2/settings.xml. See https://github.com/spring-projects/spring-boot-data-geode/issues/62. * Removes all spring-cloudcache-starter* modules. User must use the spring-gemfire-starter* modules for both -Pivotal GemFire as well as Pivotal Cloud Cache (PCC). +VMware Tanzu GemFire as well as Pivotal Cloud Cache (PCC). See https://github.com/spring-projects/spring-boot-data-geode/issues/63. * Upgrades to Spring Boot 2.2.0.RELEASE. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.2.0.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.0.RELEASE. * Upgrades to Spring Session BOM Corn-RELEASE. @@ -467,14 +467,14 @@ See https://github.com/spring-projects/spring-boot-data-geode/issues/59. See https://github.com/spring-projects/spring-boot-data-geode/issues/51. * Upgrades to Apache Geode 1.9.1. * Upgrades to Mockito 3.1.0. -* Upgrades to Pivotal GemFire 9.8.4. +* Upgrades to VMware Tanzu GemFire 9.8.4. * Upgrades to Spring Framework 5.2.0.RELEASE * Upgrades to Spring Boot 2.2.0.RC1. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.2.0.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.2.0.RELEASE. * Upgrades to Spring Data Release Train Moore-RELEASE. * Upgrades to Spring Session BOM Corn-RC1. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.2.0.RC1. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.9.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.0.RC1. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.9.RELEASE. Changes in version 1.1.2.RELEASE (2019-10-02) @@ -483,16 +483,16 @@ Fixes auto-wiring issues with auto-configured per Region GemfireTemplate beans i * Fixes auto-wiring issue with the auto-configure Region GemfireTemplate beans provided by SBDG. See https://github.com/spring-projects/spring-boot-data-geode/issues/55. -* Edits documentation providing details on how to acquire the Pivotal Cloud Cache (PCC) or Pivotal GemFire bits -when switching between Apache Geode and Pivotal GemFire or PCC. +* Edits documentation providing details on how to acquire the Pivotal Cloud Cache (PCC) or VMware Tanzu GemFire bits +when switching between Apache Geode and VMware Tanzu GemFire or PCC. See https://github.com/spring-projects/spring-boot-data-geode/issues/59. * Upgrades to Mockito 3.1.0 * Upgrades to Spring Framework 5.1.10.RELEASE. * Upgrades to Spring Boot 2.1.9.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.1.11.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.1.11.RELEASE. * Upgrades to Spring Data Release Train Lovelace-SR11. * Upgrades to Spring Session BOM Bean-SR8. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.1.6.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.6.RELEASE. Changes in version 1.2.0.M3 (2019-09-24) @@ -527,7 +527,7 @@ https://github.com/spring-projects/spring-boot-data-geode/issues/44 and bootstrapping Apache Geode Locator applications using Spring Boot and the SDG @LocatorApplication annotation. * Adds documentation to the Reference Guide on configuring and bootstrapping Apache Geode Locator-based application using Spring Boot and the SDG @LocatorApplication annotation. An example class is also provided. -* Changes Apache Geode documentation references to version 1.9 and Pivotal GemFire documentation references +* Changes Apache Geode documentation references to version 1.9 and VMware Tanzu GemFire documentation references to version 9.8. * Edits the documentation on 'Building ClientCache Applications' in the Reference Guide. * Edits the documentation on 'Building Embedded (Peer & Server) Cache Applications' in the Reference Guide. @@ -550,11 +550,11 @@ a required SDG dependency. https://github.com/spring-projects/spring-boot-data-geode/issues/45 * Upgrades to Spring Framework 5.2.0.RC2 * Upgrades to Spring Boot 2.2.0.M6 -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.2.0.RC3. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.2.0.RC3. * Upgrades to Spring Data Release Train Moore-RC3. * Upgrades to Spring Session BOM Corn-M4. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.2.0.M4. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.8.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.0.M4. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.8.RELEASE. Changes in version 1.1.1.RELEASE (2019-09-11) @@ -574,7 +574,7 @@ and disabling the ClientSecurityAutoConfiguration. * Fixes the EnableSslCondition and nested Conditions to properly consider the SBDG property for enabling and disabling the SslAutoConfiguration. * Upgrades to Spring Boot 2.1.8.RELEASE. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.8.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.8.RELEASE. Changes in version 1.2.0.M1 (2019-08-21) @@ -583,13 +583,13 @@ Rebases SBDG on Spring Framework 5.2, Spring Boot 2.2, Spring Data Moore/2.2 and * Upgrades to Apache Geode 1.9.0. * Upgrades to the Apache Geode Management REST API 1.9.0 for testing cluster configuration and Auth. -* Upgrade to Pivotal GemFire 9.8.3 +* Upgrade to VMware Tanzu GemFire 9.8.3 * Upgrades to Spring Framework 2.2.0.BUILD-SNAPSHOT. * Upgrades to Spring Boot 2.2.0.BUILD-SNAPSHOT. * Upgrades to Spring Data Release Train Moore-BUILD-SNAPSHOT. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.2.0.BUILD-SNAPSHOT. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.2.0.BUILD-SNAPSHOT. * Upgrades to Spring Session BOM Corn-BUILD-SNAPSHOT. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.2.0.BUILD-SNAPSHOT. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.2.0.BUILD-SNAPSHOT. Changes in version 1.1.0.RELEASE (2019-08-21) @@ -613,10 +613,10 @@ Adds a new Sample with Guide and Code on Near Caching. * Edits the Sample Guides on Look-Aside Caching and Inline Caching. * Upgrades to Spring Framework 5.1.9.RELEASE. * Upgrades to Spring Boot 2.1.7.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.1.10.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.1.10.RELEASE. * Upgrades to Spring Data Release Train Lovelace-SR10. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.1.5.RELEASE. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.7.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.5.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.7.RELEASE. * Upgrades to Test Containers 1.11.3. @@ -627,7 +627,7 @@ Adds a new Sample with Guide and Code on Inline Caching. * Adds a new Sample with Guide and Example Spring Boot application showcasing Inline Caching. * Refactors and cleans up the SBDG Maven POM generation. * Upgrades to Mockito 3.0.0. -* Upgrades to Pivotal GemFire 9.5.4. +* Upgrades to VMware Tanzu GemFire 9.5.4. * Upgrades to Spring Build Conventions Gradle Plugin 0.0.26.RELEASE. * Cleans up all uses of HTTP URLs, switching to HTTPS. @@ -635,42 +635,42 @@ Adds a new Sample with Guide and Code on Inline Caching. Changes in version 1.1.0.M3 (2019-07-03) ---------------------------------------- Adds support for deploying Spring Boot, ClientCache applications to Pivotal CloudFoundry (PCF) connected to an external, -standalone Apache Geode or Pivotal GemFire cluster. +standalone Apache Geode or VMware Tanzu GemFire cluster. * Adds support for hybrid cloud deployments, pushing Spring Boot, ClientCache applications to PCF connected to -an external, standalone Apache Geode or Pivotal GemFire cluster. +an external, standalone Apache Geode or VMware Tanzu GemFire cluster. * Adds support to target a specific Pivotal Cloud Cache (PCC) service instance when multiple PCC service instances are bound to a Spring Boot, ClientCache application in Pivotal CloudFoundry (PCF). -* Adds auto-configuration for Apache Geode & Pivotal GemFire logging. +* Adds auto-configuration for Apache Geode & VMware Tanzu GemFire logging. * Adds a new section in the Appendix describing how to switch between open source Apache Geode & Pivotal Cloud Cache, -or alternatively, Pivotal GemFire. +or alternatively, VMware Tanzu GemFire. * Upgrades to Spring Boot 2.1.6.RELEASE. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.5.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.5.RELEASE. * Upgrades to Spring Session BOM Bean-SR6. Changes in version 1.1.0.M2 (2019-06-14) ---------------------------------------- Adds support for the Inline Caching Use Case (UC) along with Spring Boot Starters for Spring Session -and Spring Test for Apache Geode & Pivotal GemFire (STDG). +and Spring Test for Apache Geode & VMware Tanzu GemFire (STDG). * Adds the InlineCachingRegionConfigurer, RepositoryCacheLoader and RepositoryCacheWriter to support Inline Caching. * Adds the a @EnableSecurityManagerProxy annotation for conveniently locating and configuring an Apache Geode SecurityManager implementation declared and registered as a bean in the Spring application context. * Adds the spring-geode-starter-session and spring-gemfire-starter-session modules to help users get started with -(HTTP) Session Caching using either Apache Geode or Pivotal GemFire as the provider. +(HTTP) Session Caching using either Apache Geode or VMware Tanzu GemFire as the provider. * Adds the spring-geode-starter-test and spring-gemfire-starter-test modules, which automatically pulls in -spring-boot-starter-test and Spring Test for Apache Geode & Pivotal GemFire (STDG) to help users test their Apache Geode -or Pivotal GemFire applications in a Spring context. +spring-boot-starter-test and Spring Test for Apache Geode & VMware Tanzu GemFire (STDG) to help users test their Apache Geode +or VMware Tanzu GemFire applications in a Spring context. * Includes early support for @LocatorApplication annotated Spring Boot applications enabling users to configure and bootstrap a GemFire/Geode Locator using Spring Boot. * Includes additional integration tests for customizing the auto-configuration of GemFire/Geode Pools using SDG Configurers. * Upgrades to Spring Framework 5.1.8.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.1.9.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.1.9.RELEASE. * Upgrades to Spring Data Release Train Lovelace-SR9. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.1.4.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.4.RELEASE. * Upgrades to Spring Session BOM Bean-SR5. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.4.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.4.RELEASE. Changes in version 1.0.1.RELEASE (2019-06-13) @@ -681,24 +681,24 @@ Provides support for configuring and bootstrapping Spring Boot, Apache Geode Loc * Adds the a @EnableSecurityManagerProxy annotation for conveniently locating and configuring an Apache Geode SecurityManager implementation declared and registered as a bean in the Spring application context. * Upgrades to Spring Framework 5.0.14.RELEASE. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.2.RELEASE. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.2.RELEASE. Changes in version 1.1.0.M1 (2019-05-07) ---------------------------------------- Rebases SBDG on Spring Framework 5.1, Spring Boot 2.1, Spring Data Lovelace (2.1) and Spring Session 2.1. -* Adds the @EnableSecurityManager annotation and associated configuration class to configure Apache Geode & Pivotal GemFire Security (Auth) using the CacheFactory API. -* Adds the @EnableSecurityManagerProxy annotation and associated configuration class to configure Apache Geode & Pivotal GemFire Security (Auth) using the security-manager property with proxying. +* Adds the @EnableSecurityManager annotation and associated configuration class to configure Apache Geode & VMware Tanzu GemFire Security (Auth) using the CacheFactory API. +* Adds the @EnableSecurityManagerProxy annotation and associated configuration class to configure Apache Geode & VMware Tanzu GemFire Security (Auth) using the security-manager property with proxying. * Upgrades to Apache Geode 1.6.0. * Upgrades to the Apache Geode Management REST API 1.6.0 for testing cluster configuration and Auth. -* Upgrades to Pivotal GemFire 9.5.3. +* Upgrades to VMware Tanzu GemFire 9.5.3. * Upgrades to Spring Framework 5.1.6.RELEASE. * Upgrades to Spring Boot 2.1.4.RELEASE. -* Upgrades to Spring Data for Apache Geode & Pivotal GemFire 2.1.6.RELEASE. +* Upgrades to Spring Data for Apache Geode & VMware Tanzu GemFire 2.1.6.RELEASE. * Upgrades to Spring Data Release Train Lovelace-SR6. * Upgrades to Spring Session BOM Bean-SR4. -* Upgrades to Spring Session for Apache Geode & Pivotal GemFire 2.1.3.RELEASE. +* Upgrades to Spring Session for Apache Geode & VMware Tanzu GemFire 2.1.3.RELEASE. Changes in version 1.0.0.RELEASE (2019-05-06) @@ -708,15 +708,15 @@ Edits documentation and adds Sample with Guide and Example Application code for * Fix release (milestone, release candidate, and GA) version of the reference documentation. * Fix image links in reference docs. * Add Sample with Guide and Example Application code covering the Look-Aside Caching pattern. -* Upgrade to Spring Data for Apache Geode & Pivotal GemFire Test 0.0.1.RELEASE. +* Upgrade to Spring Data for Apache Geode & VMware Tanzu GemFire Test 0.0.1.RELEASE. Changes in version 1.0.0.RC2 (2019-04-30) ----------------------------------------- -Adds additional tests and includes a sample of using Spring Boot Actuator with Apache Geode and Pivotal GemFire. +Adds additional tests and includes a sample of using Spring Boot Actuator with Apache Geode and VMware Tanzu GemFire. * Adds a sample containing a guide along with example code to show how to use Spring Boot Actuator -with Apache Geode or Pivotal GemFire. +with Apache Geode or VMware Tanzu GemFire. * Adds the 'org.springframework.boot:spring-boot-autoconfigure-processor' dependency to 'spring-geode-autoconfigure'. * Includes documentation edits. * Includes the JCache API as runtime dependency in both the 'spring-geode-starter' as well as the 'spring-gemfire-starter'. @@ -728,14 +728,14 @@ with Apache Geode or Pivotal GemFire. Changes in version 1.0.0.RC1 (2019-04-24) ----------------------------------------- -Adds support for GemfireTemplate auto-configuration for each declared Apache Geode & Pivotal GemFire Region. +Adds support for GemfireTemplate auto-configuration for each declared Apache Geode & VMware Tanzu GemFire Region. -* Adds auto-configuration to automatically create a GemfireTemplate for each declared Apache Geode or Pivotal GemFire +* Adds auto-configuration to automatically create a GemfireTemplate for each declared Apache Geode or VMware Tanzu GemFire Region (https://github.com/spring-projects/spring-boot-data-geode/issues/31). * Includes the 'Auto-configuration vs. Annotation-based configuration' chapter in reference documentation to explain the differences of each approach (https://github.com/spring-projects/spring-boot-data-geode/issues/20). * Adds a sample containing a guide along with example code to explain and show how the Spring Boot auto-configuration -support for Apache Geode & Pivotal GemFire works, complimenting the 'Auto-configuration vs. Annotation-based configuration' +support for Apache Geode & VMware Tanzu GemFire works, complimenting the 'Auto-configuration vs. Annotation-based configuration' chapter in the reference docs. * Fixes the HTTP client authentication bug when a client attempts to push cluster configuration to the server configured with a SecurityManager, requiring Authentication (https://github.com/spring-projects/spring-boot-data-geode/issues/16). @@ -762,41 +762,41 @@ and encapsulate configuration meta-data specified in properties files. * Upgrades to Spring Boot 2.0.8.RELEASE. * Upgrades to Spring Data Release Train Kay-SR13. * Upgrades to Spring Session Apple-SR8. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.1.RC1. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.1.RC1. Changes in version 1.0.0.M3 (2018-09-20) ---------------------------------------- Adds support for Spring Boot Actuator HealthIndicator endpoints providing details and insight into the runtime operation -of either Apache Geode or Pivotal GemFire. +of either Apache Geode or VMware Tanzu GemFire. Partly resolves (https://github.com/spring-projects/spring-boot-data-geode/issues/4). -* Adds Spring Boot Actuator HealthIndicators for the Apache Geode & Pivotal GemFire peer Cache and ClientCache instances, +* Adds Spring Boot Actuator HealthIndicators for the Apache Geode & VMware Tanzu GemFire peer Cache and ClientCache instances, the DistributedSystem, the DistributedMember and the ResourceManager. -* Adds Spring Boot Actuator HealthIndicators for Apache Geode & Pivotal GemFire Regions. -* Adds Spring Boot Actuator HealthIndicators for Apache Geode & Pivotal GemFire Indexes. -* Adds Spring Boot Actuator HealthIndicators for Apache Geode & Pivotal GemFire DiskStores. -* Adds Spring Boot Actuator HealthIndicators for Apache Geode & Pivotal GemFire ContinuousQueries. -* Adds Spring Boot Actuator HealthIndicators for Apache Geode & Pivotal GemFire Pools. -* Adds Spring Boot Actuator HealthIndicators for Apache Geode & Pivotal GemFire CacheServers. -* Adds Spring Boot Actuator HealthIndicators for Apache Geode & Pivotal GemFire GatewaySenders. -* Adds Spring Boot Actuator HealthIndicators for Apache Geode & Pivotal GemFire GatewayReceivers. -* Adds Spring Boot Actuator HealthIndicators for Apache Geode & Pivotal GemFire AsyncEventQueues. +* Adds Spring Boot Actuator HealthIndicators for Apache Geode & VMware Tanzu GemFire Regions. +* Adds Spring Boot Actuator HealthIndicators for Apache Geode & VMware Tanzu GemFire Indexes. +* Adds Spring Boot Actuator HealthIndicators for Apache Geode & VMware Tanzu GemFire DiskStores. +* Adds Spring Boot Actuator HealthIndicators for Apache Geode & VMware Tanzu GemFire ContinuousQueries. +* Adds Spring Boot Actuator HealthIndicators for Apache Geode & VMware Tanzu GemFire Pools. +* Adds Spring Boot Actuator HealthIndicators for Apache Geode & VMware Tanzu GemFire CacheServers. +* Adds Spring Boot Actuator HealthIndicators for Apache Geode & VMware Tanzu GemFire GatewaySenders. +* Adds Spring Boot Actuator HealthIndicators for Apache Geode & VMware Tanzu GemFire GatewayReceivers. +* Adds Spring Boot Actuator HealthIndicators for Apache Geode & VMware Tanzu GemFire AsyncEventQueues. * Upgrades to Mockito 2.22.0. * Upgrades to Spring Framework 5.0.9.RELEASE. * Upgrades to Spring Boot 2.0.5.RELEASE. * Upgrades to Spring Data Release Train Kay-SR10. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.1.M4. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.1.M4. Changes in version 1.0.0.M2 (2018-08-29) ---------------------------------------- -Adds support to auto-configure Spring Session using Apache Geode or Pivotal GemFire as the Session state +Adds support to auto-configure Spring Session using Apache Geode or VMware Tanzu GemFire as the Session state management provider. -* Adds support to auto-configure Spring Session for Apache Geode or Pivotal GemFire as the Spring Session provider -when Spring Session for Apache Geode or Pivotal GemFire is on the classpath +* Adds support to auto-configure Spring Session for Apache Geode or VMware Tanzu GemFire as the Spring Session provider +when Spring Session for Apache Geode or VMware Tanzu GemFire is on the classpath (https://github.com/spring-projects/spring-boot-data-geode/issues/3). * Improve caching provider auto-configuration to respect 'spring.cache.type' (https://github.com/spring-projects/spring-boot-data-geode/issues/11). @@ -804,23 +804,23 @@ when Spring Session for Apache Geode or Pivotal GemFire is on the classpath * Upgrades to Spring Framework 5.0.8.RELEASE. * Upgrades to Spring Boot 2.0.4.RELEASE. * Upgrades to Spring Data Release Train Kay-SR9. -* Upgrades to Spring Test for Apache Geode & Pivotal GemFire 0.0.1.M3. +* Upgrades to Spring Test for Apache Geode & VMware Tanzu GemFire 0.0.1.M3. Changes in version 1.0.0.M1 (2018-06-25) ---------------------------------------- -Inception of the Spring Boot for Apache Geode & Pivotal GemFire project. +Inception of the Spring Boot for Apache Geode & VMware Tanzu GemFire project. * Adds the spring-geode module containing the core bits and functionality for this project. * Adds the spring-geode-autoconfigure module building on Spring Boot's auto-configuration functionality. ** Includes auto-configuration for a ClientCache instance. -** Includes auto-configuration for using Apache Geode & Pivotal GemFire as a caching provider in Spring's Cache Abstraction. +** Includes auto-configuration for using Apache Geode & VMware Tanzu GemFire as a caching provider in Spring's Cache Abstraction. ** Includes auto-configuration for Spring Data Repositories. -** Includes auto-configuration for Apache Geode & Pivotal GemFire Function Execution framework. -** Includes auto-configuration for Apache Geode & Pivotal GemFire CQ. -** Includes auto-configuration for Apache Geode & Pivotal GemFire PDX serialization. -** Includes auto-configuration for Apache Geode & Pivotal GemFire Security (Authentication/Authorization). -** Includes auto-configuration for Apache Geode & Pivotal GemFire Security (TLS using SSL). +** Includes auto-configuration for Apache Geode & VMware Tanzu GemFire Function Execution framework. +** Includes auto-configuration for Apache Geode & VMware Tanzu GemFire CQ. +** Includes auto-configuration for Apache Geode & VMware Tanzu GemFire PDX serialization. +** Includes auto-configuration for Apache Geode & VMware Tanzu GemFire Security (Authentication/Authorization). +** Includes auto-configuration for Apache Geode & VMware Tanzu GemFire Security (TLS using SSL). * Adds the spring-geode-docs modules containing the project documentation and reference guide. * Adds the spring-geode-starter module to get started building Spring Boot applications with Apache Geode. -* Adds the spring-gemfire-starter module to get started building Spring Boot applications with Pivotal GemFire. +* Adds the spring-gemfire-starter module to get started building Spring Boot applications with VMware Tanzu GemFire. diff --git a/spring-geode/src/test/java/org/springframework/geode/config/annotation/ClusterAvailableConfigurationIntegrationTests.java b/spring-geode/src/test/java/org/springframework/geode/config/annotation/ClusterAvailableConfigurationIntegrationTests.java index 57b9521e..1958912d 100644 --- a/spring-geode/src/test/java/org/springframework/geode/config/annotation/ClusterAvailableConfigurationIntegrationTests.java +++ b/spring-geode/src/test/java/org/springframework/geode/config/annotation/ClusterAvailableConfigurationIntegrationTests.java @@ -21,6 +21,12 @@ import java.io.IOException; import javax.annotation.Resource; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; + import org.apache.geode.cache.DataPolicy; import org.apache.geode.cache.GemFireCache; import org.apache.geode.cache.Region; @@ -28,12 +34,6 @@ import org.apache.geode.cache.client.ClientCache; import org.apache.geode.cache.client.ClientRegionShortcut; import org.apache.geode.cache.server.CacheServer; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import org.junit.runner.RunWith; - import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.AnnotationConfigApplicationContext; @@ -54,7 +54,7 @@ import example.app.crm.service.CustomerService; /** * Integration Tests asserting the functionality and behavior of {@link EnableClusterAware} - * and {@link ClusterAvailableConfiguration} when the Apache Geode (or Pivotal GemFire) cluster of servers is available. + * and {@link ClusterAvailableConfiguration} when the Apache Geode cluster of servers is available. * * @author John Blum * @see org.junit.Test diff --git a/spring-geode/src/test/java/org/springframework/geode/config/annotation/ClusterNotAvailableConfigurationIntegrationTests.java b/spring-geode/src/test/java/org/springframework/geode/config/annotation/ClusterNotAvailableConfigurationIntegrationTests.java index 3186d051..efcfb172 100644 --- a/spring-geode/src/test/java/org/springframework/geode/config/annotation/ClusterNotAvailableConfigurationIntegrationTests.java +++ b/spring-geode/src/test/java/org/springframework/geode/config/annotation/ClusterNotAvailableConfigurationIntegrationTests.java @@ -43,7 +43,7 @@ import example.app.crm.service.CustomerService; /** * Integration Tests asserting the functionality and behavior of {@link EnableClusterAware} - * and {@link ClusterNotAvailableConfiguration} when the Apache Geode (or Pivotal GemFire) cluster of servers + * and {@link ClusterNotAvailableConfiguration} when the Apache Geode cluster of servers * is not available. * * @author John Blum diff --git a/spring-geode/src/test/java/org/springframework/geode/config/annotation/LocatorsConfigurationIntegrationTests.java b/spring-geode/src/test/java/org/springframework/geode/config/annotation/LocatorsConfigurationIntegrationTests.java index 48fbe365..d37b22d2 100644 --- a/spring-geode/src/test/java/org/springframework/geode/config/annotation/LocatorsConfigurationIntegrationTests.java +++ b/spring-geode/src/test/java/org/springframework/geode/config/annotation/LocatorsConfigurationIntegrationTests.java @@ -162,7 +162,7 @@ public class LocatorsConfigurationIntegrationTests extends SpringApplicationCont } // TODO: replace with STDG when STDG is rebased on SD[G] Moore/2.2 and STDG includes dedicated mocking support - // for Apache Geode/Pivotal GemFire Locator creation using SDG's o.s.d.g.LocatorFactoryBean + // for Apache Geode Locator creation using SDG's o.s.d.g.LocatorFactoryBean @EnableGemFireMockObjects @PeerCacheApplication(logLevel = "error") @UseLocators(locators = "mailbox[11235],skullbox[12480]", remoteLocators = "remotehost[10334]")