You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by bs...@apache.org on 2018/04/09 18:18:37 UTC
[geode] branch develop updated: GEODE-5027 Bump version to 1.6.0
and add v1.5.0 for testing
This is an automated email from the ASF dual-hosted git repository.
bschuchardt pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/geode.git
The following commit(s) were added to refs/heads/develop by this push:
new ebce148 GEODE-5027 Bump version to 1.6.0 and add v1.5.0 for testing
ebce148 is described below
commit ebce14894565900ebaf3730259a57b576f90ba80
Author: Bruce Schuchardt <bs...@pivotal.io>
AuthorDate: Mon Apr 9 11:13:10 2018 -0700
GEODE-5027 Bump version to 1.6.0 and add v1.5.0 for testing
* I bumped the version in Version.java to 1.6.0 and added a 1.6 command set
to CommandInitializer.
* I added v1.5.0 to geode-old-versions for backward compatibility testing.
* I removed junk in Version.java that hasn't been used since the SQLFire/GFX
days.
* I also removed AcceptorImpl.VERSION which seemed to serve no good purpose.
* I added a unit test to make sure that folks update the CommandInitializer
table when adding a new Version. Without this test folks would have to run
distributedTests to notice any problems with their changes.
* I changed CommandInitializer to not create new maps unless necessary.
* I fixed a test's expectation that the default connection pool exists after starting
a client cache. Starting with 1.5 the pool isn't created until it's needed.
This closes #1753
---
.../java/org/apache/geode/internal/Version.java | 72 +++++-----------
.../apache/geode/internal/cache/tier/Acceptor.java | 7 --
.../geode/internal/cache/tier/ConnectionProxy.java | 2 +-
.../tier/sockets/ClientDataSerializerMessage.java | 2 +-
.../cache/tier/sockets/ClientTombstoneMessage.java | 2 +-
.../cache/tier/sockets/CommandInitializer.java | 99 +++++++---------------
.../tier/sockets/ServerSideHandshakeFactory.java | 2 +-
.../apache/geode/internal/VersionJUnitTest.java | 22 +++++
.../rollingupgrade/RollingUpgrade2DUnitTest.java | 19 +++--
geode-old-versions/build.gradle | 1 +
10 files changed, 91 insertions(+), 137 deletions(-)
diff --git a/geode-core/src/main/java/org/apache/geode/internal/Version.java b/geode-core/src/main/java/org/apache/geode/internal/Version.java
index cf5bb5d..f7a01e7 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/Version.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/Version.java
@@ -20,6 +20,8 @@ import java.io.DataOutput;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.stream.Collectors;
import org.apache.geode.cache.UnsupportedVersionException;
import org.apache.geode.internal.cache.tier.sockets.CommandInitializer;
@@ -51,15 +53,10 @@ public class Version implements Comparable<Version> {
private final byte release;
private final byte patch;
- /**
- * Set to non-null if the underlying GemFire version is different from product version
- */
- private Version gemfireVersion;
-
/** byte used as ordinal to represent this <code>Version</code> */
private final short ordinal;
- public static final int HIGHEST_VERSION = 80;
+ public static final int HIGHEST_VERSION = 85;
private static final Version[] VALUES = new Version[HIGHEST_VERSION + 1];
@@ -212,11 +209,19 @@ public class Version implements Comparable<Version> {
public static final Version GEODE_150 =
new Version("GEODE", "1.5.0", (byte) 1, (byte) 5, (byte) 0, (byte) 0, GEODE_150_ORDINAL);
+
+ private static final byte GEODE_160_ORDINAL = 85;
+
+ public static final Version GEODE_160 =
+ new Version("GEODE", "1.6.0", (byte) 1, (byte) 6, (byte) 0, (byte) 0, GEODE_160_ORDINAL);
+
+ /* NOTE: when adding a new version bump the ordinal by 5. Ordinals can be short ints */
+
/**
* This constant must be set to the most current version of the product. !!! NOTE: update
* HIGHEST_VERSION when changing CURRENT !!!
*/
- public static final Version CURRENT = GEODE_150;
+ public static final Version CURRENT = GEODE_160;
/**
* A lot of versioning code needs access to the current version's ordinal
@@ -243,21 +248,11 @@ public class Version implements Comparable<Version> {
this.ordinal = ordinal;
this.methodSuffix = this.productName + "_" + this.majorVersion + "_" + this.minorVersion + "_"
+ this.release + "_" + this.patch;
- this.gemfireVersion = null;
if (ordinal != TOKEN_ORDINAL) {
VALUES[this.ordinal] = this;
}
}
- /**
- * Creates a new instance of <code>Version</code> with a different underlying GemFire version
- */
- private Version(String product, String name, byte major, byte minor, byte release, byte patch,
- byte ordinal, Version gemfireVersion) {
- this(product, name, major, minor, release, patch, ordinal);
- this.gemfireVersion = gemfireVersion;
- }
-
/** Return the <code>Version</code> represented by specified ordinal */
public static Version fromOrdinal(short ordinal, boolean forGFEClients)
throws UnsupportedVersionException {
@@ -335,26 +330,6 @@ public class Version implements Comparable<Version> {
}
/**
- * Fixed number of bytes required for serializing this version when "compressed" flag is false in
- * {@link #writeOrdinal(DataOutput, boolean)}.
- */
- public static int uncompressedSize() {
- return 3;
- }
-
- /**
- * Fixed number of bytes required for serializing this version when "compressed" flag is true in
- * {@link #writeOrdinal(DataOutput, boolean)}.
- */
- public int compressedSize() {
- if (ordinal <= Byte.MAX_VALUE) {
- return 1;
- } else {
- return 3;
- }
- }
-
- /**
* Write the given ordinal (result of {@link #ordinal()}) to given {@link ByteBuffer}. This keeps
* the serialization of ordinal compatible with previous versions writing a single byte to
* DataOutput when possible, and a token with 2 bytes if it is large.
@@ -364,8 +339,7 @@ public class Version implements Comparable<Version> {
* @param compressed if true, then use single byte for ordinal < 128, and three bytes for beyond
* that, else always use three bytes where the first byte is {@link #TOKEN_ORDINAL}
*/
- public static void writeOrdinal(ByteBuffer buffer, short ordinal, boolean compressed)
- throws IOException {
+ public static void writeOrdinal(ByteBuffer buffer, short ordinal, boolean compressed) {
if (compressed && ordinal <= Byte.MAX_VALUE) {
buffer.put((byte) ordinal);
} else {
@@ -446,18 +420,10 @@ public class Version implements Comparable<Version> {
}
}
- public Version getGemFireVersion() {
- return this.gemfireVersion != null ? this.gemfireVersion : this;
- }
-
public String getMethodSuffix() {
return this.methodSuffix;
}
- public String getProductName() {
- return this.productName;
- }
-
public String getName() {
return this.name;
}
@@ -482,6 +448,7 @@ public class Version implements Comparable<Version> {
return this.ordinal;
}
+
/**
* Returns whether this <code>Version</code> is compatible with the input <code>Version</code>
*
@@ -532,11 +499,7 @@ public class Version implements Comparable<Version> {
*/
@Override
public String toString() {
- if (this.gemfireVersion == null) {
- return this.productName + " " + this.name;
- } else {
- return this.productName + " " + this.name + '[' + this.gemfireVersion.toString() + ']';
- }
+ return this.productName + " " + this.name;
}
public static String toString(short ordinal) {
@@ -583,4 +546,9 @@ public class Version implements Comparable<Version> {
public boolean isPre65() {
return compareTo(Version.GFE_65) < 0;
}
+
+ public static Iterable<? extends Version> getAllVersions() {
+ return Arrays.asList(VALUES).stream().filter(x -> x != null && x != TEST_VERSION)
+ .collect(Collectors.toList());
+ }
}
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/Acceptor.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/Acceptor.java
index 22a5e43..6705f60 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/Acceptor.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/Acceptor.java
@@ -28,13 +28,6 @@ import org.apache.geode.internal.cache.tier.sockets.CacheClientNotifier;
public interface Acceptor {
/**
- * The GFE version of the server.
- *
- * @since GemFire 5.7
- */
- Version VERSION = Version.CURRENT.getGemFireVersion();
-
- /**
* Listens for a client to connect and establishes a connection to that client.
*/
void accept() throws Exception;
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/ConnectionProxy.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/ConnectionProxy.java
index 7de068b..3321c67 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/ConnectionProxy.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/ConnectionProxy.java
@@ -29,5 +29,5 @@ public interface ConnectionProxy {
*
* @since GemFire 5.7
*/
- Version VERSION = Version.CURRENT.getGemFireVersion();
+ Version VERSION = Version.CURRENT;
}
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientDataSerializerMessage.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientDataSerializerMessage.java
index 326af57..bf00657 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientDataSerializerMessage.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientDataSerializerMessage.java
@@ -217,7 +217,7 @@ public class ClientDataSerializerMessage extends ClientUpdateMessageImpl {
@Override
public boolean isClientInterested(ClientProxyMembershipID clientId) {
- return AcceptorImpl.VERSION.compareTo(Version.GFE_61) >= 0;
+ return true;
}
@Override
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientTombstoneMessage.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientTombstoneMessage.java
index be2b766..1a63c57 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientTombstoneMessage.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ClientTombstoneMessage.java
@@ -155,7 +155,7 @@ public class ClientTombstoneMessage extends ClientUpdateMessageImpl {
@Override
public boolean isClientInterested(ClientProxyMembershipID clientId) {
- return Acceptor.VERSION.compareTo(Version.GFE_70) >= 0;
+ return true;
}
@Override
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CommandInitializer.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CommandInitializer.java
index 6ad1bb3..bb666ac 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CommandInitializer.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/CommandInitializer.java
@@ -157,6 +157,8 @@ public class CommandInitializer {
private static void initializeAllCommands() {
ALL_COMMANDS = new LinkedHashMap<Version, Map<Integer, Command>>();
+ ALL_COMMANDS.put(Version.GFE_56, new HashMap<>());
+
// Initialize the GFE 5.7 commands
Map<Integer, Command> gfe57Commands = new HashMap<Integer, Command>();
ALL_COMMANDS.put(Version.GFE_57, gfe57Commands);
@@ -292,74 +294,40 @@ public class CommandInitializer {
gfe70Commands.put(MessageType.GET_PDX_ENUMS, GetPdxEnums70.getCommand());
gfe70Commands.put(MessageType.EXECUTE_FUNCTION, ExecuteFunction70.getCommand());
- Map<Integer, Command> gfe701Commands = new HashMap<Integer, Command>();
- gfe701Commands.putAll(gfe70Commands);
- ALL_COMMANDS.put(Version.GFE_701, gfe701Commands);
-
- Map<Integer, Command> gfe71Commands = new HashMap<Integer, Command>();
- gfe71Commands.putAll(ALL_COMMANDS.get(Version.GFE_701));
- ALL_COMMANDS.put(Version.GFE_71, gfe71Commands);
+ ALL_COMMANDS.put(Version.GFE_701, gfe70Commands);
+ ALL_COMMANDS.put(Version.GFE_7099, gfe70Commands);
+ ALL_COMMANDS.put(Version.GFE_71, gfe70Commands);
Map<Integer, Command> gfe80Commands = new HashMap<Integer, Command>();
gfe80Commands.putAll(ALL_COMMANDS.get(Version.GFE_71));
+ ALL_COMMANDS.put(Version.GFE_80, gfe80Commands);
// PutAll is changed to chunk responses back to the client
gfe80Commands.put(MessageType.PUTALL, PutAll80.getCommand());
- ALL_COMMANDS.put(Version.GFE_80, gfe80Commands);
- Map<Integer, Command> gfe8009Commands = new HashMap<Integer, Command>();
- gfe8009Commands.putAll(ALL_COMMANDS.get(Version.GFE_80));
- ALL_COMMANDS.put(Version.GFE_8009, gfe8009Commands);
-
- {
- Map<Integer, Command> gfe81Commands = new HashMap<Integer, Command>();
- gfe81Commands.putAll(ALL_COMMANDS.get(Version.GFE_80));
- gfe81Commands.put(MessageType.GET_ALL_WITH_CALLBACK, GetAllWithCallback.getCommand());
- gfe81Commands.put(MessageType.PUT_ALL_WITH_CALLBACK, PutAllWithCallback.getCommand());
- gfe81Commands.put(MessageType.REMOVE_ALL, RemoveAll.getCommand());
- ALL_COMMANDS.put(Version.GFE_81, gfe81Commands);
- }
- {
- Map<Integer, Command> gfe82Commands = new HashMap<Integer, Command>();
- gfe82Commands.putAll(ALL_COMMANDS.get(Version.GFE_81));
- ALL_COMMANDS.put(Version.GFE_82, gfe82Commands);
- }
- {
- Map<Integer, Command> gfe90Commands = new HashMap<Integer, Command>();
- gfe90Commands.putAll(ALL_COMMANDS.get(Version.GFE_82));
- ALL_COMMANDS.put(Version.GFE_90, gfe90Commands);
- gfe90Commands.put(MessageType.QUERY_WITH_PARAMETERS, QueryWithParametersGeode10.getCommand());
- gfe90Commands.put(MessageType.QUERY, QueryGeode10.getCommand());
- }
- {
- Map<Integer, Command> geode110Commands = new HashMap<Integer, Command>();
- geode110Commands.putAll(ALL_COMMANDS.get(Version.GFE_90));
- ALL_COMMANDS.put(Version.GEODE_110, geode110Commands);
- }
- {
- Map<Integer, Command> geode111Commands = new HashMap<Integer, Command>();
- geode111Commands.putAll(ALL_COMMANDS.get(Version.GEODE_110));
- ALL_COMMANDS.put(Version.GEODE_111, geode111Commands);
- }
- {
- Map<Integer, Command> commands = new HashMap<Integer, Command>();
- commands.putAll(ALL_COMMANDS.get(Version.GEODE_111));
- ALL_COMMANDS.put(Version.GEODE_120, commands);
- }
- {
- Map<Integer, Command> commands = new HashMap<Integer, Command>();
- commands.putAll(ALL_COMMANDS.get(Version.GEODE_120));
- ALL_COMMANDS.put(Version.GEODE_130, commands);
- }
- {
- Map<Integer, Command> commands = new HashMap<Integer, Command>();
- commands.putAll(ALL_COMMANDS.get(Version.GEODE_130));
- ALL_COMMANDS.put(Version.GEODE_140, commands);
- }
- {
- Map<Integer, Command> commands = new HashMap<Integer, Command>();
- commands.putAll(ALL_COMMANDS.get(Version.GEODE_140));
- ALL_COMMANDS.put(Version.GEODE_150, commands);
- }
+ ALL_COMMANDS.put(Version.GFE_8009, gfe80Commands);
+
+ Map<Integer, Command> gfe81Commands = new HashMap<Integer, Command>();
+ gfe81Commands.putAll(gfe80Commands);
+ gfe81Commands.put(MessageType.GET_ALL_WITH_CALLBACK, GetAllWithCallback.getCommand());
+ gfe81Commands.put(MessageType.PUT_ALL_WITH_CALLBACK, PutAllWithCallback.getCommand());
+ gfe81Commands.put(MessageType.REMOVE_ALL, RemoveAll.getCommand());
+
+ ALL_COMMANDS.put(Version.GFE_81, gfe81Commands);
+ ALL_COMMANDS.put(Version.GFE_82, gfe81Commands);
+
+ Map<Integer, Command> commands = new HashMap<Integer, Command>();
+ commands.putAll(ALL_COMMANDS.get(Version.GFE_82));
+ ALL_COMMANDS.put(Version.GFE_90, commands);
+ commands.put(MessageType.QUERY_WITH_PARAMETERS, QueryWithParametersGeode10.getCommand());
+ commands.put(MessageType.QUERY, QueryGeode10.getCommand());
+
+ ALL_COMMANDS.put(Version.GEODE_110, commands);
+ ALL_COMMANDS.put(Version.GEODE_111, commands);
+ ALL_COMMANDS.put(Version.GEODE_120, commands);
+ ALL_COMMANDS.put(Version.GEODE_130, commands);
+ ALL_COMMANDS.put(Version.GEODE_140, commands);
+ ALL_COMMANDS.put(Version.GEODE_150, commands);
+ ALL_COMMANDS.put(Version.GEODE_160, commands);
}
@@ -370,11 +338,4 @@ public class CommandInitializer {
public static Map<Integer, Command> getCommands(ServerConnection connection) {
return getCommands(connection.getClientVersion());
}
-
- /**
- * A method used by tests for Backward compatibility
- */
- public static void testSetCommands(Map<Integer, Command> testCommands) {
- ALL_COMMANDS.put(Version.TEST_VERSION, testCommands);
- }
}
diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerSideHandshakeFactory.java b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerSideHandshakeFactory.java
index fcea191..9f760bc 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerSideHandshakeFactory.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/cache/tier/sockets/ServerSideHandshakeFactory.java
@@ -36,7 +36,7 @@ import org.apache.geode.internal.security.SecurityService;
class ServerSideHandshakeFactory {
private static final Logger logger = LogService.getLogger();
- static final Version currentServerVersion = Acceptor.VERSION;
+ static final Version currentServerVersion = Version.CURRENT;
ServerSideHandshake readHandshake(Socket socket, int timeout, CommunicationMode communicationMode,
DistributedSystem system, SecurityService securityService) throws Exception {
diff --git a/geode-core/src/test/java/org/apache/geode/internal/VersionJUnitTest.java b/geode-core/src/test/java/org/apache/geode/internal/VersionJUnitTest.java
index 8cd4d81..3ce3736 100644
--- a/geode-core/src/test/java/org/apache/geode/internal/VersionJUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/internal/VersionJUnitTest.java
@@ -20,6 +20,8 @@ import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import org.apache.geode.cache.UnsupportedVersionException;
+import org.apache.geode.internal.cache.tier.sockets.CommandInitializer;
import org.apache.geode.test.junit.categories.UnitTest;
@Category(UnitTest.class)
@@ -34,6 +36,12 @@ public class VersionJUnitTest {
compare(Version.GFE_81, Version.GFE_70);
compare(Version.GFE_81, Version.GFE_71);
compare(Version.GFE_81, Version.GFE_80);
+ compare(Version.GFE_82, Version.GFE_81);
+ compare(Version.GEODE_110, Version.GFE_82);
+ compare(Version.GEODE_120, Version.GEODE_111);
+ compare(Version.GEODE_130, Version.GEODE_120);
+ compare(Version.GEODE_140, Version.GEODE_130);
+ compare(Version.GEODE_150, Version.GEODE_140);
}
private void compare(Version later, Version earlier) {
@@ -53,4 +61,18 @@ public class VersionJUnitTest {
assertFalse(Version.GFE_65.isPre65());
assertFalse(Version.GFE_70.isPre65());
}
+
+ @Test
+ public void testCommandMapContainsAllVersions() {
+ for (Version version : Version.getAllVersions()) {
+ org.junit.Assert.assertNotNull(
+ "Please add a commnd set for " + version + " of Geode to CommandInitializer",
+ CommandInitializer.getCommands(version));
+ }
+ }
+
+ @Test
+ public void testFromOrdinalForCurrentVersionSucceeds() throws UnsupportedVersionException {
+ Version.fromOrdinal(Version.CURRENT_ORDINAL, true);
+ }
}
diff --git a/geode-core/src/test/java/org/apache/geode/internal/cache/rollingupgrade/RollingUpgrade2DUnitTest.java b/geode-core/src/test/java/org/apache/geode/internal/cache/rollingupgrade/RollingUpgrade2DUnitTest.java
index 9dae29f..059f8ab 100755
--- a/geode-core/src/test/java/org/apache/geode/internal/cache/rollingupgrade/RollingUpgrade2DUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/internal/cache/rollingupgrade/RollingUpgrade2DUnitTest.java
@@ -87,6 +87,7 @@ import org.apache.geode.internal.Version;
import org.apache.geode.internal.cache.CacheServerImpl;
import org.apache.geode.internal.cache.DiskInitFile;
import org.apache.geode.internal.cache.GemFireCacheImpl;
+import org.apache.geode.internal.cache.InternalCache;
import org.apache.geode.internal.cache.Oplog;
import org.apache.geode.internal.cache.Oplog.OPLOG_TYPE;
import org.apache.geode.internal.cache.tier.sockets.CacheClientProxy;
@@ -1387,6 +1388,7 @@ public class RollingUpgrade2DUnitTest extends JUnit4DistributedTestCase {
public Properties getClientSystemProperties() {
Properties p = new Properties();
p.setProperty("mcast-port", "0");
+ p.setProperty(DistributionConfig.LOG_LEVEL_NAME, DUnitLauncher.logLevel);
return p;
}
@@ -1685,7 +1687,11 @@ public class RollingUpgrade2DUnitTest extends JUnit4DistributedTestCase {
cf.addPoolLocator(hosts[i], ports[i]);
}
- return cf.create();
+ ClientCache clientCache = cf.create();
+ // the pool is lazily created starting in 1.5.0. Here we ask for the pool so it
+ // will be instantiated
+ clientCache.getDefaultPool();
+ return clientCache;
}
public static boolean assertRegionExists(GemFireCache cache, String regionName) throws Exception {
@@ -1924,10 +1930,13 @@ public class RollingUpgrade2DUnitTest extends JUnit4DistributedTestCase {
}
private String getHARegionName() {
- assertEquals(1, ((GemFireCacheImpl) cache).getCacheServers().size());
- CacheServerImpl bs =
- (CacheServerImpl) ((GemFireCacheImpl) cache).getCacheServers().iterator().next();
- assertEquals(1, bs.getAcceptor().getCacheClientNotifier().getClientProxies().size());
+ InternalCache internalCache = (InternalCache) cache;
+ Awaitility.await().atMost(15, TimeUnit.SECONDS).until(() -> {
+ assertEquals(1, internalCache.getCacheServers().size());
+ CacheServerImpl bs = (CacheServerImpl) (internalCache.getCacheServers().iterator().next());
+ assertEquals(1, bs.getAcceptor().getCacheClientNotifier().getClientProxies().size());
+ });
+ CacheServerImpl bs = (CacheServerImpl) internalCache.getCacheServers().iterator().next();
CacheClientProxy ccp =
bs.getAcceptor().getCacheClientNotifier().getClientProxies().iterator().next();
return ccp.getHARegion().getName();
diff --git a/geode-old-versions/build.gradle b/geode-old-versions/build.gradle
index c394630..3fea08e 100644
--- a/geode-old-versions/build.gradle
+++ b/geode-old-versions/build.gradle
@@ -95,4 +95,5 @@ task createGeodeClasspathsFile {
addOldVersion('test120', '1.2.0', true)
addOldVersion('test130', '1.3.0', true)
addOldVersion('test140', '1.4.0', true)
+ addOldVersion('test150', '1.5.0', true)
}
--
To stop receiving notification emails like this one, please contact
bschuchardt@apache.org.