| /* |
| * 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, |
| TimeSpan freeConnectionTimeout, |
| TimeSpan loadConditioningInterval, |
| int minConnections, |
| int maxConnections, |
| int retryAttempts, |
| TimeSpan idleTimeout, |
| TimeSpan pingInterval, |
| string name, |
| TimeSpan readTimeout, |
| string serverGroup, |
| int socketBufferSize, |
| bool subscriptionEnabled, |
| TimeSpan subscriptionMessageTrackingTimeout, |
| TimeSpan subscriptionAckInterval, |
| int subscriptionRedundancy, |
| TimeSpan statisticInterval, |
| int threadLocalConnections, |
| bool prSingleHopEnabled, |
| TimeSpan 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; |
| |
| var cache = new CacheFactory() |
| .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 = cache.GetPoolManager().Find(poolNameRegion1); |
| Pool poolOfRegion2 = cache.GetPoolManager().Find(poolNameRegion2); |
| Pool poolOfSubRegion = cache.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, TimeSpan.FromMilliseconds(12345), TimeSpan.FromMilliseconds(23456), 3, 7, 3, TimeSpan.FromMilliseconds(5555), TimeSpan.FromMilliseconds(12345), |
| "test_pool_1", TimeSpan.FromMilliseconds(23456), "ServerGroup1", 32768, true, TimeSpan.FromMilliseconds(900123), TimeSpan.FromMilliseconds(567), 0, TimeSpan.FromMilliseconds(10123), 5, true, TimeSpan.FromMilliseconds(250001)); |
| |
| bool check2 = checkPoolAttributes(poolOfRegion2, null, servers, TimeSpan.FromMilliseconds(23456), TimeSpan.FromMilliseconds(34567), 2, 8, 5, TimeSpan.FromMilliseconds(6666), TimeSpan.FromMilliseconds(23456), |
| "test_pool_2", TimeSpan.FromMilliseconds(34567), "ServerGroup2", 65536, false, TimeSpan.FromMilliseconds(800222), TimeSpan.FromMilliseconds(678), 1, TimeSpan.FromMilliseconds(20345), 3, false, TimeSpan.FromMilliseconds(5000)); |
| |
| bool check3 = checkPoolAttributes(poolOfSubRegion, null, servers, TimeSpan.FromMilliseconds(23456), TimeSpan.FromMilliseconds(34567), 2, 8, 5, TimeSpan.FromMilliseconds(6666), TimeSpan.FromMilliseconds(23456), |
| "test_pool_2", TimeSpan.FromMilliseconds(34567), "ServerGroup2", 65536, false, TimeSpan.FromMilliseconds(800222), TimeSpan.FromMilliseconds(678), 1, TimeSpan.FromMilliseconds(20345), 3, false, TimeSpan.FromMilliseconds(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 = new CacheFactory() |
| .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 = new CacheFactory() |
| .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 = new CacheFactory() |
| .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 = new CacheFactory() |
| .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(TimeSpan.FromSeconds(10000)); |
| factory.SetLoadConditioningInterval(TimeSpan.FromSeconds(1)); |
| factory.SetSocketBufferSize(1024); |
| factory.SetReadTimeout(TimeSpan.FromSeconds(10)); |
| factory.SetMinConnections(2); |
| factory.SetMaxConnections(5); |
| factory.SetIdleTimeout(TimeSpan.FromSeconds(5)); |
| factory.SetRetryAttempts(5); |
| factory.SetPingInterval(TimeSpan.FromSeconds(1)); |
| factory.SetUpdateLocatorListInterval(TimeSpan.FromMilliseconds(122000)); |
| factory.SetStatisticInterval(TimeSpan.FromSeconds(1)); |
| factory.SetServerGroup("ServerGroup1"); |
| factory.SetSubscriptionEnabled(true); |
| factory.SetSubscriptionRedundancy(1); |
| factory.SetSubscriptionMessageTrackingTimeout(TimeSpan.FromSeconds(5)); |
| factory.SetSubscriptionAckInterval(TimeSpan.FromSeconds(1)); |
| factory.AddLocator("localhost", CacheHelper.LOCATOR_PORT_1); |
| factory.SetPRSingleHopEnabled(false); |
| |
| Pool pool = factory.Create(poolName); |
| |
| Assert.AreEqual(TimeSpan.FromSeconds(10000), pool.FreeConnectionTimeout, "FreeConnectionTimeout"); |
| Assert.AreEqual(TimeSpan.FromSeconds(1), pool.LoadConditioningInterval, "LoadConditioningInterval"); |
| Assert.AreEqual(1024, pool.SocketBufferSize, "SocketBufferSize"); |
| Assert.AreEqual(TimeSpan.FromSeconds(10), pool.ReadTimeout, "ReadTimeout"); |
| Assert.AreEqual(2, pool.MinConnections, "MinConnections"); |
| Assert.AreEqual(5, pool.MaxConnections, "MaxConnections"); |
| Assert.AreEqual(TimeSpan.FromSeconds(5), pool.IdleTimeout, "IdleTimeout"); |
| Assert.AreEqual(5, pool.RetryAttempts, "RetryAttempts"); |
| Assert.AreEqual(TimeSpan.FromSeconds(1), pool.PingInterval, "PingInterval"); |
| Assert.AreEqual(TimeSpan.FromMilliseconds(122000), pool.UpdateLocatorListInterval, "UpdateLocatorListInterval"); |
| Assert.AreEqual(TimeSpan.FromSeconds(1), pool.StatisticInterval, "StatisticInterval"); |
| Assert.AreEqual("ServerGroup1", pool.ServerGroup, "ServerGroup"); |
| Assert.AreEqual(true, pool.SubscriptionEnabled, "SubscriptionEnabled"); |
| Assert.AreEqual(1, pool.SubscriptionRedundancy, "SubscriptionRedundancy"); |
| Assert.AreEqual(TimeSpan.FromSeconds(5), pool.SubscriptionMessageTrackingTimeout, "SubscriptionMessageTrackingTimeout"); |
| Assert.AreEqual(TimeSpan.FromSeconds(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(); |
| 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(TimeSpan.FromSeconds(10000), pool.FreeConnectionTimeout, "FreeConnectionTimeout"); |
| Assert.AreEqual(TimeSpan.FromSeconds(1), pool.LoadConditioningInterval, "LoadConditioningInterval"); |
| Assert.AreEqual(1024, pool.SocketBufferSize, "SocketBufferSize"); |
| Assert.AreEqual(TimeSpan.FromSeconds(10), pool.ReadTimeout, "ReadTimeout"); |
| Assert.AreEqual(2, pool.MinConnections, "MinConnections"); |
| Assert.AreEqual(5, pool.MaxConnections, "MaxConnections"); |
| Assert.AreEqual(TimeSpan.FromSeconds(5), pool.IdleTimeout, "IdleTimeout"); |
| Assert.AreEqual(5, pool.RetryAttempts, "RetryAttempts"); |
| Assert.AreEqual(TimeSpan.FromSeconds(1), pool.PingInterval, "PingInterval"); |
| Assert.AreEqual(TimeSpan.FromMilliseconds(25000), pool.UpdateLocatorListInterval, "UpdateLocatorListInterval"); |
| Assert.AreEqual(TimeSpan.FromSeconds(1), pool.StatisticInterval, "StatisticInterval"); |
| Assert.AreEqual("ServerGroup1", pool.ServerGroup, "ServerGroup"); |
| Assert.AreEqual(true, pool.SubscriptionEnabled, "SubscriptionEnabled"); |
| Assert.AreEqual(1, pool.SubscriptionRedundancy, "SubscriptionRedundancy"); |
| Assert.AreEqual(TimeSpan.FromSeconds(5), pool.SubscriptionMessageTrackingTimeout, "SubscriptionMessageTrackingTimeout"); |
| Assert.AreEqual(TimeSpan.FromSeconds(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); |
| 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"); |
| } |
| catch (NotConnectedException excp) |
| { |
| if (excp.InnerException is NoAvailableLocatorsException) |
| { |
| Util.Log("Got expected NoAvailableLocatorsException with cause 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, true); |
| Region region2 = CacheHelper.GetVerifyRegion<object, object>("PoolRegion2"); |
| region2.GetSubscriptionService().RegisterAllKeys(false, true); |
| Region region3 = CacheHelper.GetVerifyRegion<object, object>("PoolRegion3"); |
| region3.GetSubscriptionService().RegisterAllKeys(false, 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 |
| } |
| } |
