You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by jb...@apache.org on 2017/08/11 23:52:52 UTC
[36/52] [partial] geode-native git commit: GEODE-3165: Reogranized
sources relative to the root for better CMake IDE integration.
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/ThinClientPoolTestsN.cs
----------------------------------------------------------------------
diff --git a/clicache/integration-test/ThinClientPoolTestsN.cs b/clicache/integration-test/ThinClientPoolTestsN.cs
new file mode 100644
index 0000000..32e0d5e
--- /dev/null
+++ b/clicache/integration-test/ThinClientPoolTestsN.cs
@@ -0,0 +1,901 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+
+namespace Apache.Geode.Client.UnitTests
+{
+ using NUnit.Framework;
+ using Apache.Geode.DUnitFramework;
+ using Apache.Geode.Client;
+ using Region = Apache.Geode.Client.IRegion<Object, Object>;
+
+ [TestFixture]
+ [Category("group2")]
+ [Category("unicast_only")]
+ [Category("generics")]
+ public class ThinClientPoolTests : ThinClientRegionSteps
+ {
+ #region Private members
+
+ private UnitProcess m_client1, m_client2;
+
+ #endregion
+
+ protected override ClientBase[] GetClients()
+ {
+ m_client1 = new UnitProcess();
+ m_client2 = new UnitProcess();
+ return new ClientBase[] { m_client1, m_client2 };
+ }
+
+ [TestFixtureTearDown]
+ public override void EndTests()
+ {
+ CacheHelper.StopJavaServers();
+ base.EndTests();
+ }
+
+ [TearDown]
+ public override void EndTest()
+ {
+ try
+ {
+ CacheHelper.ClearEndpoints();
+ CacheHelper.ClearLocators();
+ }
+ finally
+ {
+ CacheHelper.StopJavaServers();
+ CacheHelper.StopJavaLocators();
+ }
+ base.EndTest();
+ }
+
+ bool checkPoolAttributes
+ (
+ Client.Pool pool,
+ string[] locators,
+ string[] servers,
+ int freeConnectionTimeout,
+ int loadConditioningInterval,
+ int minConnections,
+ int maxConnections,
+ int retryAttempts,
+ int idleTimeout,
+ int pingInterval,
+ string name,
+ int readTimeout,
+ string serverGroup,
+ int socketBufferSize,
+ bool subscriptionEnabled,
+ int subscriptionMessageTrackingTimeout,
+ int subscriptionAckInterval,
+ int subscriptionRedundancy,
+ int statisticInterval,
+ int threadLocalConnections,
+ bool prSingleHopEnabled,
+ int updateLocatorListInterval
+ )
+ {
+ if (pool == null)
+ {
+ Util.Log("checkPoolAttributes: pool is null");
+ return false;
+ }
+ Util.Log("checkPoolAttributes: Checking pool " + pool.Name);
+ if (!pool.Name.Equals(name))
+ {
+ Util.Log("checkPoolAttributes: Pool name expected [{0}], actual [{1}]", name, pool.Name);
+ return false;
+ }
+ if (!Util.CompareArrays(locators, pool.Locators))
+ {
+ Util.Log("checkPoolAttributes: locator list mismatch");
+ return false;
+ }
+ if (servers != null && !Util.CompareArrays(servers, pool.Servers))
+ {
+ Util.Log("checkPoolAttributes: server list mismatch");
+ return false;
+ }
+ if (freeConnectionTimeout != pool.FreeConnectionTimeout)
+ {
+ Util.Log("checkPoolAttributes: FreeConnectionTimeout expected {0}, actual {1}",
+ freeConnectionTimeout, pool.FreeConnectionTimeout);
+ return false;
+ }
+ if (loadConditioningInterval != pool.LoadConditioningInterval)
+ {
+ Util.Log("checkPoolAttributes: LoadConditioningInterval expected {0}, actual {1}",
+ loadConditioningInterval, pool.LoadConditioningInterval);
+ return false;
+ }
+ if (minConnections != pool.MinConnections)
+ {
+ Util.Log("checkPoolAttributes: MinConnections expected {0}, actual {1}",
+ minConnections, pool.MinConnections);
+ return false;
+ }
+ if (maxConnections != pool.MaxConnections)
+ {
+ Util.Log("checkPoolAttributes: MaxConnections expected {0}, actual {1}",
+ maxConnections, pool.MaxConnections);
+ return false;
+ }
+ if (retryAttempts != pool.RetryAttempts)
+ {
+ Util.Log("checkPoolAttributes: RetryAttempts expected {0}, actual {1}",
+ retryAttempts, pool.RetryAttempts);
+ return false;
+ }
+ if (idleTimeout != pool.IdleTimeout)
+ {
+ Util.Log("checkPoolAttributes: IdleTimeout expected {0}, actual {1}",
+ idleTimeout, pool.IdleTimeout);
+ return false;
+ }
+ if (pingInterval != pool.PingInterval)
+ {
+ Util.Log("checkPoolAttributes: PingInterval expected {0}, actual {1}",
+ pingInterval, pool.PingInterval);
+ return false;
+ }
+ if (readTimeout != pool.ReadTimeout)
+ {
+ Util.Log("checkPoolAttributes: ReadTimeout expected {0}, actual {1}",
+ readTimeout, pool.ReadTimeout);
+ return false;
+ }
+ if (!serverGroup.Equals(pool.ServerGroup))
+ {
+ Util.Log("checkPoolAttributes: ServerGroup expected {0}, actual {1}",
+ serverGroup, pool.ServerGroup);
+ return false;
+ }
+ if (socketBufferSize != pool.SocketBufferSize)
+ {
+ Util.Log("checkPoolAttributes: SocketBufferSize expected {0}, actual {1}",
+ socketBufferSize, pool.SocketBufferSize);
+ return false;
+ }
+ if (subscriptionEnabled != pool.SubscriptionEnabled)
+ {
+ Util.Log("checkPoolAttributes: SubscriptionEnabled expected {0}, actual {1}",
+ subscriptionEnabled, pool.SubscriptionEnabled);
+ return false;
+ }
+ if (subscriptionMessageTrackingTimeout != pool.SubscriptionMessageTrackingTimeout)
+ {
+ Util.Log("checkPoolAttributes: SubscriptionMessageTrackingTimeout expected {0}, actual {1}",
+ subscriptionMessageTrackingTimeout, pool.SubscriptionMessageTrackingTimeout);
+ return false;
+ }
+ if (subscriptionAckInterval != pool.SubscriptionAckInterval)
+ {
+ Util.Log("checkPoolAttributes: SubscriptionAckInterval expected {0}, actual {1}",
+ subscriptionAckInterval, pool.SubscriptionAckInterval);
+ return false;
+ }
+ if (subscriptionRedundancy != pool.SubscriptionRedundancy)
+ {
+ Util.Log("checkPoolAttributes: SubscriptionRedundancy expected {0}, actual {1}",
+ subscriptionRedundancy, pool.SubscriptionRedundancy);
+ return false;
+ }
+ if (statisticInterval != pool.StatisticInterval)
+ {
+ Util.Log("checkPoolAttributes: StatisticInterval expected {0}, actual {1}",
+ statisticInterval, pool.StatisticInterval);
+ return false;
+ }
+ if (prSingleHopEnabled != pool.PRSingleHopEnabled)
+ {
+ Util.Log("checkPoolAttributes: PRSingleHopEnabled expected {0}, actual {1}",
+ prSingleHopEnabled, pool.PRSingleHopEnabled);
+ return false;
+ }
+ if (updateLocatorListInterval != pool.UpdateLocatorListInterval)
+ {
+ Util.Log("checkPoolAttributes: updateLocatorListInterval expected {0}, actual {1}",
+ updateLocatorListInterval, pool.UpdateLocatorListInterval);
+ return false;
+ }
+ /* TODO: Enable this check when available
+ if (threadLocalConnections != pool.ThreadLocalConnections)
+ {
+ Util.Log("checkPoolAttributes: ThreadLocalConnections expected {0}, actual {1}",
+ threadLocalConnections, pool.ThreadLocalConnections);
+ return false;
+ }
+ * */
+ Util.Log("checkPoolAttributes: Checked pool: OK");
+ return true;
+ }
+
+ public void runPoolXmlCreation()
+ {
+ string xmlLocation = CacheHelper.TestDir + Path.DirectorySeparatorChar + "valid_cache_pool.xml";
+
+ string duplicateXMLFile = Util.Rand(3432898).ToString() + "valid_cache_pool.xml";
+ CacheHelper.createDuplicateXMLFile(xmlLocation, duplicateXMLFile);
+ xmlLocation = duplicateXMLFile;
+
+ Cache cache = CacheFactory.CreateCacheFactory()
+ .Set("cache-xml-file", xmlLocation)
+ .Create();
+
+ Region[] rootRegions = cache.RootRegions<object, object>();
+ Assert.AreEqual(2, rootRegions.Length);
+
+ ICollection<IRegion<object, object>> subRegionsCol = rootRegions[0].SubRegions(true);
+ Region[] subRegions = new Region[subRegionsCol.Count];
+ subRegionsCol.CopyTo(subRegions, 0);
+ Assert.AreEqual(1, subRegions.Length);
+
+ ICollection<IRegion<object, object>> subRegions2Col = rootRegions[1].SubRegions(true);
+ Region[] subRegions2 = new Region[subRegions2Col.Count];
+ subRegions2Col.CopyTo(subRegions2, 0);
+ Assert.AreEqual(0, subRegions2.Length);
+
+ string poolNameRegion1 = rootRegions[0].Attributes.PoolName;
+ string poolNameRegion2 = rootRegions[1].Attributes.PoolName;
+ string poolNameSubRegion = subRegions[0].Attributes.PoolName;
+
+ Assert.AreEqual("test_pool_1", poolNameRegion1);
+ Assert.AreEqual("test_pool_2", poolNameRegion2);
+ Assert.AreEqual("test_pool_2", poolNameSubRegion);
+
+ Pool poolOfRegion1 = CacheHelper.DCache.GetPoolManager().Find(poolNameRegion1);
+ Pool poolOfRegion2 = CacheHelper.DCache.GetPoolManager().Find(poolNameRegion2);
+ Pool poolOfSubRegion = CacheHelper.DCache.GetPoolManager().Find(poolNameSubRegion);
+
+ string[] locators = new string[1] { "localhost:" + CacheHelper.LOCATOR_PORT_1 };
+ string[] servers = new string[2] { "localhost:" + CacheHelper.HOST_PORT_1, "localhost:" + CacheHelper.HOST_PORT_2 };
+
+ // ARB:
+ // TODO: check if server list contains the two endpoints (currently using null argument for servers list)
+ bool check1 = checkPoolAttributes(poolOfRegion1, locators, null, 12345, 23456, 3, 7, 3, 5555, 12345,
+ "test_pool_1", 23456, "ServerGroup1", 32768, true, 900123, 567, 0, 10123, 5, true, 250001);
+
+ bool check2 = checkPoolAttributes(poolOfRegion2, null, servers, 23456, 34567, 2, 8, 5, 6666, 23456,
+ "test_pool_2", 34567, "ServerGroup2", 65536, false, 800222, 678, 1, 20345, 3, false, 5000);
+
+ bool check3 = checkPoolAttributes(poolOfSubRegion, null, servers, 23456, 34567, 2, 8, 5, 6666, 23456,
+ "test_pool_2", 34567, "ServerGroup2", 65536, false, 800222, 678, 1, 20345, 3, false, 5000);
+
+ Assert.IsTrue(check1, "Attribute check 1 failed");
+ Assert.IsTrue(check2, "Attribute check 2 failed");
+ Assert.IsTrue(check3, "Attribute check 3 failed");
+
+ cache.Close();
+ try
+ {
+ Util.Log("Testing invalid_cache_pool.xml");
+ xmlLocation = CacheHelper.TestDir + Path.DirectorySeparatorChar + "invalid_cache_pool.xml";
+ duplicateXMLFile = Util.Rand(3432898).ToString() + "invalid_cache_pool.xml";
+ CacheHelper.createDuplicateXMLFile(xmlLocation, duplicateXMLFile);
+ xmlLocation = duplicateXMLFile;
+ cache = CacheFactory.CreateCacheFactory()
+ .Set("cache-xml-file", xmlLocation)
+ .Create();
+ Assert.Fail("invalid_cache_pool.xml did not throw exception");
+ }
+ catch (GeodeException excp)
+ {
+ Util.Log("Expected {0}: {1}", excp.GetType().Name, excp.Message);
+ }
+
+ try
+ {
+ Util.Log("Testing invalid_cache_pool2.xml");
+ xmlLocation = CacheHelper.TestDir + Path.DirectorySeparatorChar + "invalid_cache_pool2.xml";
+ duplicateXMLFile = Util.Rand(3432898).ToString() + "invalid_cache_pool2.xml";
+ CacheHelper.createDuplicateXMLFile(xmlLocation, duplicateXMLFile);
+ xmlLocation = duplicateXMLFile;
+ cache = CacheFactory.CreateCacheFactory()
+ .Set("cache-xml-file", xmlLocation)
+ .Create();
+ Assert.Fail("invalid_cache_pool2.xml did not throw exception");
+ }
+ catch (GeodeException excp)
+ {
+ Util.Log("Expected {0}: {1}", excp.GetType().Name, excp.Message);
+ }
+
+ try
+ {
+ Util.Log("Testing invalid_cache_pool3.xml");
+ xmlLocation = CacheHelper.TestDir + Path.DirectorySeparatorChar + "invalid_cache_pool3.xml";
+ duplicateXMLFile = "invalid_cache_pool3.xml";
+ CacheHelper.createDuplicateXMLFile(xmlLocation, duplicateXMLFile);
+ xmlLocation = duplicateXMLFile;
+ cache = CacheFactory.CreateCacheFactory()
+ .Set("cache-xml-file", xmlLocation)
+ .Create();
+ Assert.Fail("invalid_cache_pool3.xml did not throw exception");
+ }
+ catch (GeodeException excp)
+ {
+ Util.Log("Expected {0}: {1}", excp.GetType().Name, excp.Message);
+ }
+
+ try
+ {
+ Util.Log("Testing invalid_cache_pool4.xml");
+ xmlLocation = CacheHelper.TestDir + Path.DirectorySeparatorChar + "invalid_cache_pool4.xml";
+ duplicateXMLFile = Util.Rand(3432898).ToString() + "invalid_cache_pool4.xml";
+ CacheHelper.createDuplicateXMLFile(xmlLocation, duplicateXMLFile);
+ xmlLocation = duplicateXMLFile;
+ cache = CacheFactory.CreateCacheFactory()
+ .Set("cache-xml-file", xmlLocation)
+ .Create();
+ Assert.Fail("invalid_cache_pool4.xml did not throw exception");
+ }
+ catch (GeodeException excp)
+ {
+ Util.Log("Expected {0}: {1}", excp.GetType().Name, excp.Message);
+ }
+
+ }
+
+ public void createPoolAndTestAttrs(string poolName)
+ {
+ CacheHelper.Init();
+
+ PoolFactory factory = CacheHelper.DCache.GetPoolManager().CreateFactory();
+ factory.SetFreeConnectionTimeout(10000);
+ factory.SetLoadConditioningInterval(1);
+ factory.SetSocketBufferSize(1024);
+ factory.SetReadTimeout(10);
+ factory.SetMinConnections(2);
+ factory.SetMaxConnections(5);
+ factory.SetIdleTimeout(5);
+ factory.SetRetryAttempts(5);
+ factory.SetPingInterval(1);
+ factory.SetUpdateLocatorListInterval(122000);
+ factory.SetStatisticInterval(1);
+ factory.SetServerGroup("ServerGroup1");
+ factory.SetSubscriptionEnabled(true);
+ factory.SetSubscriptionRedundancy(1);
+ factory.SetSubscriptionMessageTrackingTimeout(5);
+ factory.SetSubscriptionAckInterval(1);
+ factory.AddLocator("localhost", CacheHelper.LOCATOR_PORT_1);
+ factory.SetPRSingleHopEnabled(false);
+
+ Pool pool = factory.Create(poolName, CacheHelper.DCache);
+
+ Assert.AreEqual(10000, pool.FreeConnectionTimeout, "FreeConnectionTimeout");
+ Assert.AreEqual(1, pool.LoadConditioningInterval, "LoadConditioningInterval");
+ Assert.AreEqual(1024, pool.SocketBufferSize, "SocketBufferSize");
+ Assert.AreEqual(10, pool.ReadTimeout, "ReadTimeout");
+ Assert.AreEqual(2, pool.MinConnections, "MinConnections");
+ Assert.AreEqual(5, pool.MaxConnections, "MaxConnections");
+ Assert.AreEqual(5, pool.IdleTimeout, "IdleTimeout");
+ Assert.AreEqual(5, pool.RetryAttempts, "RetryAttempts");
+ Assert.AreEqual(1, pool.PingInterval, "PingInterval");
+ Assert.AreEqual(122000, pool.UpdateLocatorListInterval, "UpdateLocatorListInterval");
+ Assert.AreEqual(1, pool.StatisticInterval, "StatisticInterval");
+ Assert.AreEqual("ServerGroup1", pool.ServerGroup, "ServerGroup");
+ Assert.AreEqual(true, pool.SubscriptionEnabled, "SubscriptionEnabled");
+ Assert.AreEqual(1, pool.SubscriptionRedundancy, "SubscriptionRedundancy");
+ Assert.AreEqual(5, pool.SubscriptionMessageTrackingTimeout, "SubscriptionMessageTrackingTimeout");
+ Assert.AreEqual(1, pool.SubscriptionAckInterval, "SubscriptionAckInterval");
+ Assert.AreEqual(false, pool.PRSingleHopEnabled, "PRSingleHopEnabled");
+ }
+
+ public void testPoolAttrs(string poolName)
+ {
+ string xmlFile = CacheHelper.TestDir + Path.DirectorySeparatorChar + "cacheserver_pool_client.xml";
+ string duplicateXMLFile = Util.Rand(3432898).ToString() + "cacheserver_pool_client.xml";
+ CacheHelper.createDuplicateXMLFile(xmlFile, duplicateXMLFile);
+ xmlFile = duplicateXMLFile;
+ Properties<string, string> config = Properties<string, string>.Create<string, string>();
+ config.Insert("cache-xml-file", xmlFile);
+ CacheHelper.InitConfig(config);
+
+ Pool pool = CacheHelper.DCache.GetPoolManager().Find(poolName);
+
+ Assert.AreEqual("clientPool", pool.Name, "Pool Name");
+ Assert.AreEqual(10000, pool.FreeConnectionTimeout, "FreeConnectionTimeout");
+ Assert.AreEqual(1, pool.LoadConditioningInterval, "LoadConditioningInterval");
+ Assert.AreEqual(1024, pool.SocketBufferSize, "SocketBufferSize");
+ Assert.AreEqual(10, pool.ReadTimeout, "ReadTimeout");
+ Assert.AreEqual(2, pool.MinConnections, "MinConnections");
+ Assert.AreEqual(5, pool.MaxConnections, "MaxConnections");
+ Assert.AreEqual(5, pool.IdleTimeout, "IdleTimeout");
+ Assert.AreEqual(5, pool.RetryAttempts, "RetryAttempts");
+ Assert.AreEqual(1, pool.PingInterval, "PingInterval");
+ Assert.AreEqual(25000, pool.UpdateLocatorListInterval, "UpdateLocatorListInterval");
+ Assert.AreEqual(1, pool.StatisticInterval, "StatisticInterval");
+ Assert.AreEqual("ServerGroup1", pool.ServerGroup, "ServerGroup");
+ Assert.AreEqual(true, pool.SubscriptionEnabled, "SubscriptionEnabled");
+ Assert.AreEqual(1, pool.SubscriptionRedundancy, "SubscriptionRedundancy");
+ Assert.AreEqual(5, pool.SubscriptionMessageTrackingTimeout, "SubscriptionMessageTrackingTimeout");
+ Assert.AreEqual(1, pool.SubscriptionAckInterval, "SubscriptionAckInterval");
+ Assert.AreEqual(false, pool.PRSingleHopEnabled, "PRSingleHopEnabled");
+ }
+
+ public void testExistingPool(string poolName)
+ {
+ PoolFactory factory = CacheHelper.DCache.GetPoolManager().CreateFactory();
+ try
+ {
+ factory.Create(poolName, CacheHelper.DCache);
+ Assert.Fail("Did not get expected IllegalStateException");
+ }
+ catch (IllegalStateException /*excp*/)
+ {
+ Util.Log("Got expected IllegalStateException");
+ }
+ catch (Exception excp)
+ {
+ Assert.Fail("Got unexpected {0}: {1}", excp.GetType().Name, excp.Message);
+ }
+ }
+
+ public void createRegionAndAttachPool(string regionName, string poolName)
+ {
+ CacheHelper.CreateTCRegion_Pool<object, object>(regionName, true, true, null, null, poolName, false);
+ }
+
+ public void testPoolLevels()
+ {
+ // Currently we do not have a way to get CacheImpl test helpers in C#
+ Util.Log("testPoolLevels: Currently we do not have a way to get CacheImpl test helpers in C#");
+
+ // Step 1: Check pool level == min
+
+ // Step 2: Spawn multiple threads doing ops
+
+ // Step 3: Check pool level == max since threads are active.
+
+ // Step 4: Wait for pool.IdleTimeout to pass.
+
+ // Step 5: Check pool level again == min.
+
+ return;
+ }
+
+ void runPoolAttributes()
+ {
+ CacheHelper.SetupJavaServers(true, "cacheserver1_pool.xml", "cacheserver2_pool.xml");
+ CacheHelper.StartJavaLocator(1, "GFELOC");
+ CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+ CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+
+ m_client1.Call(CacheHelper.setPorts, CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2, CacheHelper.HOST_PORT_3, CacheHelper.LOCATOR_PORT_1, CacheHelper.LOCATOR_PORT_2);
+ m_client1.Call(createPoolAndTestAttrs, "__TEST_POOL1__");
+ m_client1.Call(testExistingPool, "__TEST_POOL1__");
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion1", "__TEST_POOL1__");
+
+ m_client2.Call(CacheHelper.setPorts, CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2, CacheHelper.HOST_PORT_3, CacheHelper.LOCATOR_PORT_1, CacheHelper.LOCATOR_PORT_2);
+ m_client2.Call(testPoolAttrs, "clientPool");
+
+ m_client1.Call(testPoolLevels);
+
+ m_client1.Call(Close);
+ Util.Log("Client 1 closed");
+ m_client2.Call(Close);
+ Util.Log("Client 2 closed");
+
+ CacheHelper.StopJavaServer(1);
+ Util.Log("Cacheserver 1 stopped.");
+ CacheHelper.StopJavaServer(2);
+ Util.Log("Cacheserver 2 stopped.");
+
+ CacheHelper.StopJavaLocator(1);
+ Util.Log("Locator 1 stopped.");
+
+ CacheHelper.ClearEndpoints();
+ CacheHelper.ClearLocators();
+ }
+
+ public void createPooledRegion(string regionName, string poolName, string locators)
+ {
+ CacheHelper.CreateTCRegion_Pool<object, object>(regionName, true, true, null, locators, poolName, false);
+ }
+
+ public void createPooledRegionWithNotification(string regionName, string poolName, string locators)
+ {
+ CacheHelper.CreateTCRegion_Pool<object, object>(regionName, true, true, null, locators, poolName, true);
+ }
+
+ public void createPool(string name, string locators, string serverGroup,
+ int redundancy, bool subscription)
+ {
+ CacheHelper.CreatePool<object, object>(name, locators, serverGroup, redundancy, subscription);
+ }
+
+ public void checkLocators1()
+ {
+ try
+ {
+ InvalidateEntry(RegionName, m_keys[1]);
+ UpdateEntry(RegionName, m_keys[0], m_vals[0], false);
+ Assert.Fail("Did not get expected NotConnectedException");
+ }
+ catch (NotConnectedException /*excp*/)
+ {
+ Util.Log("Got expected NotConnectedException");
+ }
+ }
+
+ public void checkLocators2()
+ {
+ try
+ {
+ InvalidateEntry(RegionName, m_keys[0]);
+ UpdateEntry(RegionName, m_keys[1], m_vals[1], false);
+ Assert.Fail("Did not get expected NotConnectedException with cause NoAvailableLocatorsException");
+ }
+ catch (NotConnectedException excp)
+ {
+ if (excp.InnerException is NoAvailableLocatorsException)
+ {
+ Util.Log("Got expected NoAvailableLocatorsException");
+ }
+ else
+ {
+ Assert.Fail("Did not get expected NotConnectedException with cause NoAvailableLocatorsException");
+ }
+ }
+ }
+
+ void runPoolLocator()
+ {
+ CacheHelper.createRandomPorts();
+ string locators = "localhost:" + (CacheHelper.LOCATOR_PORT_1);
+ locators = locators + ",localhost:" + (CacheHelper.LOCATOR_PORT_2);
+ m_client1.Call(createPooledRegion, RegionName, "Pool1", locators.Split(',')[0]);
+ m_client2.Call(createPooledRegion, RegionName, "Pool2", locators.Split(',')[0]);
+
+ m_client1.Call(createPooledRegionWithNotification, RegionNames[1], "Pool3", locators.Split(',')[0]);
+ m_client2.Call(createPooledRegionWithNotification, RegionNames[1], "Pool3", locators.Split(',')[0]);
+
+ m_client1.Call(CreateEntryWithLocatorException, RegionName, m_keys[0], m_vals[0]);
+ m_client1.Call(CreateEntryWithLocatorException, RegionNames[1], m_keys[0], m_vals[0]);
+
+ CacheHelper.SetupJavaServers(true, "cacheserver.xml", "cacheserver2.xml");
+ CacheHelper.StartJavaLocator(1, "GFELOC1");
+ CacheHelper.StartJavaLocator(2, "GFELOC2");
+ CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+
+ m_client1.Call(CreateEntry, RegionName, m_keys[0], m_vals[0]);
+ m_client2.Call(DoNetsearch, RegionName, m_keys[0], m_vals[0], true);
+ m_client2.Call(CreateEntry, RegionName, m_keys[1], m_vals[1]);
+
+ m_client1.Call(CreateEntry, RegionNames[1], m_keys[0], m_vals[0]);
+
+ CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 2);
+ CacheHelper.StopJavaServer(1);
+
+ m_client2.Call(DoNetsearch, RegionNames[1], m_keys[0], m_vals[0], false);
+
+ m_client1.Call(DoNetsearch, RegionName, m_keys[1], m_vals[1], true);
+ m_client1.Call(UpdateEntry, RegionName, m_keys[0], m_nvals[0], true);
+
+ m_client2.Call(InvalidateEntry, RegionName, m_keys[0]);
+ m_client2.Call(DoNetsearch, RegionName, m_keys[0], m_nvals[0], false);
+ m_client2.Call(UpdateEntry, RegionName, m_keys[1], m_nvals[1], true);
+
+ CacheHelper.StopJavaLocator(1);
+ CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+ CacheHelper.StopJavaServer(2);
+
+ m_client1.Call(checkLocators1);
+
+ CacheHelper.StopJavaLocator(2);
+ m_client2.Call(checkLocators2);
+
+ m_client1.Call(Close);
+ m_client2.Call(Close);
+
+ CacheHelper.StopJavaServer(1);
+
+ CacheHelper.ClearEndpoints();
+ CacheHelper.ClearLocators();
+ }
+
+ public void checkCacheServerException(string region, string key, string val)
+ {
+ try
+ {
+ CreateEntry(region, key, val);
+ Assert.Fail("Did not get expected RegionNotFoundException");
+ }
+ catch (CacheServerException excp)
+ {
+ Util.Log("Got expected {0}: {1}", excp.GetType().Name, excp.Message);
+ }
+ }
+
+ void runPoolServer()
+ {
+ CacheHelper.SetupJavaServers(true, "cacheserver1_pool.xml", "cacheserver2_pool.xml", "cacheserver3_pool.xml");
+ CacheHelper.StartJavaLocator(1, "GFELOC1");
+ CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+ CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+ CacheHelper.StartJavaServerWithLocators(3, "GFECS3", 1);
+
+ m_client1.Call(CacheHelper.setPorts, CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2, CacheHelper.HOST_PORT_3, CacheHelper.LOCATOR_PORT_1, CacheHelper.LOCATOR_PORT_2);
+ m_client1.Call(createPool, "__TEST_POOL1__", CacheHelper.Locators, "ServerGroup1", 0, false);
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion1", "__TEST_POOL1__");
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion2", "__TEST_POOL1__");
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion3", "__TEST_POOL1__");
+
+ m_client1.Call(CacheHelper.setPorts, CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2, CacheHelper.HOST_PORT_3, CacheHelper.LOCATOR_PORT_1, CacheHelper.LOCATOR_PORT_2);
+ m_client2.Call(createPool, "__TEST_POOL1__", CacheHelper.Locators, (string)null, 0, false);
+ m_client2.Call(createRegionAndAttachPool, "PoolRegion1", "__TEST_POOL1__");
+ m_client2.Call(createRegionAndAttachPool, "PoolRegion2", "__TEST_POOL1__");
+ m_client2.Call(createRegionAndAttachPool, "PoolRegion3", "__TEST_POOL1__");
+
+ m_client1.Call(CreateEntry, "PoolRegion1", m_keys[0], m_vals[0]);
+
+ m_client1.Call(checkCacheServerException, "PoolRegion2", m_keys[0], m_vals[0]);
+
+ m_client2.Call(CreateEntry, "PoolRegion1", m_keys[0], m_vals[0]);
+ m_client2.Call(CreateEntry, "PoolRegion2", m_keys[0], m_vals[0]);
+
+ m_client2.Call(checkCacheServerException, "PoolRegion3", m_keys[0], m_vals[0]);
+
+ m_client1.Call(Close);
+ m_client2.Call(Close);
+
+ CacheHelper.StopJavaServer(1);
+ CacheHelper.StopJavaServer(2);
+ CacheHelper.StopJavaServer(3);
+
+ CacheHelper.StopJavaLocator(1);
+ CacheHelper.ClearEndpoints();
+ CacheHelper.ClearLocators();
+ }
+
+ public void feedEntries(int keyIndex, bool newValue, bool update)
+ {
+ if (!update)
+ {
+ CreateEntry("PoolRegion1", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex]);
+ CreateEntry("PoolRegion2", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex]);
+ CreateEntry("PoolRegion3", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex]);
+ }
+ else
+ {
+ UpdateEntry("PoolRegion1", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex], false);
+ UpdateEntry("PoolRegion2", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex], false);
+ UpdateEntry("PoolRegion3", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex], false);
+ }
+ }
+
+ public void verifyEntries(int keyIndex, bool netSearch, bool newValue)
+ {
+ if (!netSearch)
+ {
+ VerifyEntry("PoolRegion1", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex]);
+ VerifyEntry("PoolRegion2", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex]);
+ VerifyEntry("PoolRegion3", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex]);
+ }
+ else
+ {
+ DoNetsearch("PoolRegion1", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex], false);
+ DoNetsearch("PoolRegion2", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex], false);
+ DoNetsearch("PoolRegion3", m_keys[keyIndex], newValue ? m_nvals[keyIndex] : m_vals[keyIndex], false);
+ }
+ }
+
+ public void verifyEntries2()
+ {
+ Region region = CacheHelper.GetVerifyRegion<object, object>("PoolRegion3");
+ string cKey = m_keys[1];
+
+ string cVal = (string)region[cKey];
+
+ Assert.IsNotNull(cVal, "Value should not be null.");
+ if (cVal != m_nvals[1])
+ return;//ServerGroup2 is no more up
+
+ Assert.Fail("Looks like value from ServerGroup2 found, even no server is up");
+ }
+
+ public void registerAllKeys()
+ {
+ Region region1 = CacheHelper.GetVerifyRegion<object, object>("PoolRegion1");
+ region1.GetSubscriptionService().RegisterAllKeys(false, null, true);
+ Region region2 = CacheHelper.GetVerifyRegion<object, object>("PoolRegion2");
+ region2.GetSubscriptionService().RegisterAllKeys(false, null, true);
+ Region region3 = CacheHelper.GetVerifyRegion<object, object>("PoolRegion3");
+ region3.GetSubscriptionService().RegisterAllKeys(false, null, true);
+ }
+
+ void runPoolRedundancy()
+ {
+ for (int runIndex = 0; runIndex < 2; runIndex++)
+ {
+ CacheHelper.SetupJavaServers(true, "CacheServPoolRedun1.xml", "CacheServPoolRedun2.xml",
+ "CacheServPoolRedun3.xml");
+ CacheHelper.StartJavaLocator(1, "GFELOC1");
+ CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+ CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+ CacheHelper.StartJavaServerWithLocators(3, "GFECS3", 1);
+ m_client1.Call(CacheHelper.setPorts, CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2, CacheHelper.HOST_PORT_3, CacheHelper.LOCATOR_PORT_1, CacheHelper.LOCATOR_PORT_2);
+ m_client2.Call(CacheHelper.setPorts, CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2, CacheHelper.HOST_PORT_3, CacheHelper.LOCATOR_PORT_1, CacheHelper.LOCATOR_PORT_2);
+
+ if (runIndex == 0)
+ {
+ m_client1.Call(createPool, "Pool1", CacheHelper.Locators, "ServerGroup1", 2, true);
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion1", "Pool1");
+ m_client1.Call(createPool, "Pool2", CacheHelper.Locators, "ServerGroup1", 1, true);
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion2", "Pool2");
+ m_client1.Call(createPool, "Pool3", CacheHelper.Locators, "ServerGroup1", 0, true);
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion3", "Pool3");
+ m_client1.Call(feedEntries, 0, false, false);
+ m_client1.Call(registerAllKeys);
+
+ m_client2.Call(createPool, "Pool1", CacheHelper.Locators, (string)null, 2, true);
+ m_client2.Call(createRegionAndAttachPool, "PoolRegion1", "Pool1");
+ m_client2.Call(createPool, "Pool2", CacheHelper.Locators, (string)null, 1, true);
+ m_client2.Call(createRegionAndAttachPool, "PoolRegion2", "Pool2");
+ m_client2.Call(createPool, "Pool3", CacheHelper.Locators, (string)null, 0, true);
+ m_client2.Call(createRegionAndAttachPool, "PoolRegion3", "Pool3");
+ m_client2.Call(feedEntries, 1, false, false);
+ m_client2.Call(registerAllKeys);
+ m_client2.Call(verifyEntries, 0, true, false);
+ }
+ else
+ {
+ m_client1.Call(createPool, "Pool1", CacheHelper.Locators, "ServerGroup1", 2, true);
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion1", "Pool1");
+ m_client1.Call(createPool, "Pool2", CacheHelper.Locators, "ServerGroup2", 1, true);
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion2", "Pool2");
+ m_client1.Call(createPool, "Pool3", CacheHelper.Locators, "ServerGroup3", 0, true);
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion3", "Pool3");
+ m_client1.Call(feedEntries, 0, false, false);
+ m_client1.Call(registerAllKeys);
+
+ m_client2.Call(createPool, "Pool1", CacheHelper.Locators, (string)null, 2, true);
+ m_client2.Call(createRegionAndAttachPool, "PoolRegion1", "Pool1");
+ m_client2.Call(createPool, "Pool2", CacheHelper.Locators, (string)null, 1, true);
+ m_client2.Call(createRegionAndAttachPool, "PoolRegion2", "Pool2");
+ m_client2.Call(createPool, "Pool3", CacheHelper.Locators, (string)null, 0, true);
+ m_client2.Call(createRegionAndAttachPool, "PoolRegion3", "Pool3");
+ m_client2.Call(feedEntries, 1, false, false);
+ m_client2.Call(registerAllKeys);
+ m_client2.Call(verifyEntries, 0, true, false);
+ }
+
+ m_client1.Call(verifyEntries, 1, false, false);
+
+ if (runIndex == 0)
+ {
+ CacheHelper.StopJavaServer(1);
+ CacheHelper.StopJavaServer(2);
+ }
+
+ /*CacheHelper.StopJavaServer(3);
+ CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+ CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+ CacheHelper.StartJavaServerWithLocators(3, "GFECS3", 1);*/
+
+ Thread.Sleep(20000);
+ m_client1.Call(feedEntries, 0, true, true);
+ m_client2.Call(verifyEntries, 0, false, true);
+ if (runIndex == 1)
+ {
+ CacheHelper.StopJavaServer(1);
+ }
+ Thread.Sleep(20000);
+ m_client2.Call(feedEntries, 1, true, true);
+ if (runIndex == 0)
+ m_client1.Call(verifyEntries, 1, false, true);
+ else
+ m_client1.Call(verifyEntries2);
+
+ m_client1.Call(Close);
+ m_client2.Call(Close);
+
+ //CacheHelper.StopJavaServer(1);
+ if (runIndex == 1)
+ CacheHelper.StopJavaServer(2);
+ CacheHelper.StopJavaServer(3);
+
+ CacheHelper.StopJavaLocator(1);
+
+ CacheHelper.ClearEndpoints();
+ CacheHelper.ClearLocators();
+ }
+ }
+
+ void runPoolRegisterInterest()
+ {
+ CacheHelper.SetupJavaServers(true, "cacheserver1_pool.xml", "cacheserver3_pool.xml");
+ CacheHelper.StartJavaLocator(1, "GFELOC1");
+ CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+ CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+ m_client1.Call(CacheHelper.setPorts, CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2, CacheHelper.HOST_PORT_3, CacheHelper.LOCATOR_PORT_1, CacheHelper.LOCATOR_PORT_2);
+ m_client1.Call(createPool, "__TEST_POOL1__", CacheHelper.Locators, "ServerGroup1", 0, true);
+ m_client1.Call(createRegionAndAttachPool, "PoolRegion1", "__TEST_POOL1__");
+ m_client1.Call(RegisterAllKeys, new string[] { "PoolRegion1" });
+
+ Util.Log("TODO: Code to check client notification connection with Server1 and not Server2");
+
+ m_client1.Call(Close);
+
+ CacheHelper.StopJavaServer(1);
+ CacheHelper.StopJavaServer(2);
+
+ CacheHelper.StopJavaLocator(1);
+ CacheHelper.ClearEndpoints();
+ CacheHelper.ClearLocators();
+ }
+
+ #region Tests
+
+ [Test]
+ public void PoolXmlCreation()
+ {
+ CacheHelper.SetupJavaServers(true, "cacheserver1_pool.xml", "cacheserver2_pool.xml");
+ CacheHelper.StartJavaLocator(1, "GFELOC");
+ // ARB:
+ // TODO: in validation, check if server list contains the two endpoints (currently using null argument for servers list)
+ // Following lines should be uncommented for checking the above.
+ //CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
+ //CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1);
+
+ m_client1.Call(CacheHelper.setPorts, CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2, CacheHelper.HOST_PORT_3, CacheHelper.LOCATOR_PORT_1, CacheHelper.LOCATOR_PORT_2);
+ m_client1.Call(runPoolXmlCreation);
+
+ //CacheHelper.StopJavaServer(1);
+ //CacheHelper.StopJavaServer(2);
+ CacheHelper.StopJavaLocator(1);
+ }
+
+ [Test]
+ public void PoolAttributes()
+ {
+ runPoolAttributes();
+ }
+
+ [Test]
+ public void PoolLocator()
+ {
+ runPoolLocator();
+ }
+
+ [Test]
+ public void PoolServer()
+ {
+ runPoolServer();
+ }
+
+ [Test]
+ public void PoolRedundancy()
+ {
+ runPoolRedundancy();
+ }
+
+ [Test]
+ public void PoolRegisterInterest()
+ {
+ runPoolRegisterInterest();
+ }
+
+ #endregion
+ }
+}