http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/ThinClientHARegionTestsN.cs ---------------------------------------------------------------------- diff --git a/clicache/integration-test/ThinClientHARegionTestsN.cs b/clicache/integration-test/ThinClientHARegionTestsN.cs new file mode 100644 index 0000000..5a00367 --- /dev/null +++ b/clicache/integration-test/ThinClientHARegionTestsN.cs @@ -0,0 +1,991 @@ +/* + * 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.Threading; + +namespace Apache.Geode.Client.UnitTests +{ + using NUnit.Framework; + using Apache.Geode.DUnitFramework; + using Apache.Geode.Client.Tests; + using Apache.Geode.Client; + + using Region = Apache.Geode.Client.IRegion<Object, Object>; + + [TestFixture] + [Category("group4")] + [Category("unicast_only")] + [Category("generics")] + public class ThinClientHARegionTests : ThinClientRegionSteps + { + #region Private members + + private UnitProcess m_client1, m_client2, m_client3; + private string[] m_regexes = { "Key.*1", "Key.*2", "Key.*3", "Key.*4" }; + + private static string QueryRegionName = "Portfolios"; + + #endregion + + protected override string ExtraPropertiesFile + { + get + { + return "geode.properties.mixed"; + } + } + + protected override ClientBase[] GetClients() + { + m_client1 = new UnitProcess(); + m_client2 = new UnitProcess(); + m_client3 = new UnitProcess(); + return new ClientBase[] { m_client1, m_client2, m_client3 }; + } + + [TearDown] + public override void EndTest() + { + try + { + m_client1.Call(CacheHelper.Close); + m_client2.Call(CacheHelper.Close); + m_client3.Call(CacheHelper.Close); + CacheHelper.ClearEndpoints(); + } + finally + { + CacheHelper.StopJavaServers(); + } + base.EndTest(); + } + + #region Various steps for HA tests + + public void InitClient_Pool(string locators, int redundancyLevel) + { + CacheHelper.CreatePool<object, object>("__TESTPOOL1_", locators, null, redundancyLevel, true); + } + + public void InitClientForEventId_Pool(string locators, bool notification, + int redundancyLevel, int ackInterval, int dupCheckLife) + { + CacheHelper.Init(); + CacheHelper.CreatePool<object, object>("__TESTPOOL1_", locators, null, + redundancyLevel, notification, ackInterval, dupCheckLife); + } + + public void InitClientXml(string cacheXml) + { + CacheHelper.InitConfig(cacheXml); + } + + public void InitClientXml(string cacheXml, int serverport1, int serverport2) + { + CacheHelper.HOST_PORT_1 = serverport1; + CacheHelper.HOST_PORT_2 = serverport2; + CacheHelper.InitConfig(cacheXml); + } + + public void CreateEntriesForEventId(int sleep) + { + IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); + IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[1]); + + for (int value = 1; value <= 100; value++) + { + region1[m_keys[0]] = value; + Thread.Sleep(sleep); + region1[m_keys[1]] = value; + Thread.Sleep(sleep); + region1[m_keys[2]] = value; + Thread.Sleep(sleep); + region1[m_keys[3]] = value; + Thread.Sleep(sleep); + region2[m_keys[0]] = value; + Thread.Sleep(sleep); + region2[m_keys[1]] = value; + Thread.Sleep(sleep); + region2[m_keys[2]] = value; + Thread.Sleep(sleep); + region2[m_keys[3]] = value; + Thread.Sleep(sleep); + } + } + + public void CheckClientForEventId() + { + IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); + IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[1]); + + DupListener<object, object> checker1 = region1.Attributes.CacheListener as DupListener<object, object>; + DupListener<object, object> checker2 = region2.Attributes.CacheListener as DupListener<object, object>; + + Util.Log("Validating checker1 cachelistener"); + checker1.validate(); + Util.Log("Validating checker2 cachelistener"); + checker2.validate(); + } + + public void InitDupListeners() + { + IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); + IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[1]); + + region1.AttributesMutator.SetCacheListener(DupListener<object, object>.Create()); + region2.AttributesMutator.SetCacheListener(DupListener<object, object>.Create()); + + Thread.Sleep(5000); + + region1.GetSubscriptionService().RegisterAllKeys(); + region2.GetSubscriptionService().RegisterAllKeys(); + } + + public void CreateHATCRegions(string[] regionNames, bool useList, + string locators, bool clientNotification, bool create) + { + if (create) + { + CacheHelper.CreateTCRegion_Pool<object, object>(regionNames[0], true, true, + null, locators, "__TESTPOOL1_", clientNotification); + CacheHelper.CreateTCRegion_Pool<object, object>(regionNames[1], false, true, + null, locators, "__TESTPOOL1_", clientNotification); + } + m_regionNames = regionNames; + } + + /* + public void CreateCPPRegion(string regionName) + { + CacheHelper.CreateTCRegion(regionName, true, true, + null, "none", false); + } + * */ + + public void CreateMixedEntry(string regionName, string key, string val) + { + CreateEntry(regionName, key, val); + } + + public void DoNetsearchMixed(string regionName, string key, string val, bool checkNoKey) + { + DoNetsearch(regionName, key, val, checkNoKey); + } + + public void UpdateEntryMixed(string regionName, string key, string val, bool checkVal) + { + UpdateEntry(regionName, key, val, checkVal); + } + + public void LocalDestroyEntry(string regionName, string key) + { + Util.Log("Locally Destroying entry -- key: {0} in region {1}", + key, regionName); + + // Destroy entry, verify entry is destroyed + Region region = CacheHelper.GetVerifyRegion<object, object>(regionName); + Assert.IsTrue(region.ContainsKey(key), "Key should have been found in region."); + region.GetLocalView().Remove(key); + VerifyDestroyed(regionName, key); + } + + public void Create2Vals(bool even) + { + if (even) + { + CreateEntry(m_regionNames[0], m_keys[0], m_vals[0]); + CreateEntry(m_regionNames[1], m_keys[2], m_vals[2]); + } + else + { + CreateEntry(m_regionNames[0], m_keys[1], m_vals[1]); + CreateEntry(m_regionNames[1], m_keys[3], m_vals[3]); + } + } + + public void CreateVals() + { + Create2Vals(true); + Create2Vals(false); + } + + public void VerifyValCreations(bool even) + { + if (even) + { + VerifyCreated(m_regionNames[0], m_keys[0]); + VerifyCreated(m_regionNames[1], m_keys[2]); + } + else + { + VerifyCreated(m_regionNames[0], m_keys[1]); + VerifyCreated(m_regionNames[1], m_keys[3]); + } + } + + public void VerifyTallies() + { + IRegion<object, object> region1 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); + IRegion<object, object> region2 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[1]); + + TallyLoader<object, object> loader1 = (TallyLoader<object, object>)region1.Attributes.CacheLoader; + TallyListener<object, object> listener1 = (TallyListener<object, object>) region1.Attributes.CacheListener; + TallyWriter<object, object> writer1 = (TallyWriter<object, object>)region1.Attributes.CacheWriter; + TallyResolver<object, object> resolver1 = (TallyResolver<object, object>) region1.Attributes.PartitionResolver; + + TallyLoader<object, object> loader2 = (TallyLoader<object, object>)region2.Attributes.CacheLoader; + TallyListener<object, object> listener2 = (TallyListener<object, object>)region2.Attributes.CacheListener; + TallyWriter<object, object> writer2 = (TallyWriter<object, object>)region2.Attributes.CacheWriter; + TallyResolver<object, object> resolver2 = (TallyResolver<object, object>)region2.Attributes.PartitionResolver; + + loader1.ShowTallies(); + writer1.ShowTallies(); + listener1.ShowTallies(); + resolver1.ShowTallies(); + + loader2.ShowTallies(); + writer2.ShowTallies(); + listener2.ShowTallies(); + resolver2.ShowTallies(); + + // We don't assert for partition resolver because client metadata service may + // not have fetched PR single hop info to trigger the resolver. + + Assert.AreEqual(1, loader1.ExpectLoads(1)); + //Assert.AreEqual(1, resolver1.ExpectLoads(1)); + Assert.AreEqual(1, writer1.ExpectCreates(1)); + Assert.AreEqual(0, writer1.ExpectUpdates(0)); + Assert.AreEqual(2, listener1.ExpectCreates(2)); + Assert.AreEqual(1, listener1.ExpectUpdates(1)); + + Assert.AreEqual(1, loader2.ExpectLoads(1)); + //Assert.AreEqual(1, resolver2.ExpectLoads(1)); + Assert.AreEqual(1, writer2.ExpectCreates(1)); + Assert.AreEqual(0, writer2.ExpectUpdates(0)); + Assert.AreEqual(2, listener2.ExpectCreates(2)); + Assert.AreEqual(1, listener2.ExpectUpdates(1)); + } + + public void UpdateVals() + { + UpdateEntry(m_regionNames[0], m_keys[0], m_vals[0], true); + UpdateEntry(m_regionNames[0], m_keys[1], m_vals[1], true); + UpdateEntry(m_regionNames[1], m_keys[2], m_vals[2], true); + UpdateEntry(m_regionNames[1], m_keys[3], m_vals[3], true); + } + + public void Update2NVals(bool even, bool checkVal) + { + if (even) + { + UpdateEntry(m_regionNames[0], m_keys[0], m_nvals[0], checkVal); + UpdateEntry(m_regionNames[1], m_keys[2], m_nvals[2], checkVal); + } + else + { + UpdateEntry(m_regionNames[0], m_keys[1], m_nvals[1], checkVal); + UpdateEntry(m_regionNames[1], m_keys[3], m_nvals[3], checkVal); + } + } + + public void UpdateNVals(bool checkVal) + { + Update2NVals(true, checkVal); + Update2NVals(false, checkVal); + } + + public void Verify2Vals(bool even) + { + if (even) + { + VerifyEntry(m_regionNames[0], m_keys[0], m_vals[0]); + VerifyEntry(m_regionNames[1], m_keys[2], m_vals[2]); + } + else + { + VerifyEntry(m_regionNames[0], m_keys[1], m_vals[1]); + VerifyEntry(m_regionNames[1], m_keys[3], m_vals[3]); + } + } + + public void VerifyVals() + { + Verify2Vals(true); + Verify2Vals(false); + } + + public void Verify2NVals(bool even) + { + if (even) + { + VerifyEntry(m_regionNames[0], m_keys[0], m_nvals[0]); + VerifyEntry(m_regionNames[1], m_keys[2], m_nvals[2]); + } + else + { + VerifyEntry(m_regionNames[0], m_keys[1], m_nvals[1]); + VerifyEntry(m_regionNames[1], m_keys[3], m_nvals[3]); + } + } + + public void DoNetsearch2Vals(bool even) + { + if (even) + { + DoNetsearch(m_regionNames[0], m_keys[0], m_vals[0], true); + DoNetsearch(m_regionNames[1], m_keys[2], m_vals[2], true); + } + else + { + DoNetsearch(m_regionNames[0], m_keys[1], m_vals[1], true); + DoNetsearch(m_regionNames[1], m_keys[3], m_vals[3], true); + } + } + + public void DoCacheLoad2Vals(bool even) + { + if (even) + { + DoCacheLoad(m_regionNames[0], m_keys[0], m_vals[0], true); + DoCacheLoad(m_regionNames[1], m_keys[2], m_vals[2], true); + } + else + { + DoCacheLoad(m_regionNames[0], m_keys[1], m_vals[1], true); + DoCacheLoad(m_regionNames[1], m_keys[3], m_vals[3], true); + } + } + + public void DoNetsearchVals() + { + DoNetsearch2Vals(true); + DoNetsearch2Vals(false); + } + + public void VerifyNVals() + { + Verify2NVals(true); + Verify2NVals(false); + } + + public void VerifyNValsVals() + { + VerifyEntry(m_regionNames[0], m_keys[0], m_nvals[0], true); + VerifyEntry(m_regionNames[0], m_keys[1], m_vals[1], true); + VerifyEntry(m_regionNames[1], m_keys[2], m_nvals[2], true); + VerifyEntry(m_regionNames[1], m_keys[3], m_vals[3], true); + } + + public void VerifyNValVals() + { + VerifyEntry(m_regionNames[0], m_keys[0], m_nvals[0], true); + VerifyEntry(m_regionNames[0], m_keys[1], m_vals[1], true); + VerifyEntry(m_regionNames[1], m_keys[2], m_vals[2], true); + VerifyEntry(m_regionNames[1], m_keys[3], m_vals[3], true); + } + + public void VerifyValsNVals() + { + VerifyEntry(m_regionNames[0], m_keys[0], m_vals[0], true); + VerifyEntry(m_regionNames[0], m_keys[1], m_nvals[1], true); + VerifyEntry(m_regionNames[1], m_keys[2], m_vals[2], true); + VerifyEntry(m_regionNames[1], m_keys[3], m_nvals[3], true); + } + + public void VerifyMixedNVals() + { + VerifyEntry(m_regionNames[0], m_keys[0], m_nvals[0], true); + VerifyEntry(m_regionNames[0], m_keys[1], m_vals[1], true); + VerifyEntry(m_regionNames[1], m_keys[2], m_vals[2], true); + VerifyEntry(m_regionNames[1], m_keys[3], m_nvals[3], true); + } + + public void RegisterKeysException(string key0, string key1) + { + Region region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); + Region region1 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[1]); + if (key0 != null) + { + region0.GetSubscriptionService().RegisterKeys(new string[] {key0 }); + } + if (key1 != null) + { + region1.GetSubscriptionService().RegisterKeys(new string[] {key1 }); + } + } + + public void RegisterRegexesException(string regex0, string regex1) + { + if (regex0 != null) + { + Region region0 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[0]); + region0.GetSubscriptionService().RegisterRegex(regex0); + } + if (regex1 != null) + { + Region region1 = CacheHelper.GetVerifyRegion<object, object>(m_regionNames[1]); + region1.GetSubscriptionService().RegisterRegex(regex1); + } + } + + public void DistOpsCommonSteps(bool clientNotification) + { + DistOpsCommonSteps(clientNotification, true); + } + + public void DistOpsCommonSteps(bool clientNotification, bool createRegions) + { + m_client1.Call(CreateHATCRegions, RegionNames, false, + (string)null, clientNotification, createRegions); + m_client1.Call(Create2Vals, true); + Util.Log("StepOne complete."); + + m_client2.Call(CreateHATCRegions, RegionNames, false, + CacheHelper.Locators, !clientNotification, createRegions); + m_client2.Call(Create2Vals, false); + Util.Log("StepTwo complete."); + + m_client1.Call(DoNetsearch2Vals, false); + m_client1.Call(RegisterKeys, m_keys[1], m_keys[3]); + Util.Log("StepThree complete."); + + m_client2.Call(CheckServerKeys); + m_client2.Call(DoNetsearch2Vals, true); + m_client2.Call(RegisterKeys, m_keys[0], m_keys[2]); + Util.Log("StepFour complete."); + + m_client1.Call(Update2NVals, true, true); + Util.Log("StepFive complete."); + + m_client2.Call(Verify2NVals, true); + m_client2.Call(Update2NVals, false, true); + Util.Log("StepSix complete."); + + m_client1.Call(Verify2NVals, false); + Util.Log("StepSeven complete."); + } + + public void FailoverCommonSteps(int redundancyLevel, bool useRegexes) + { + CacheHelper.SetupJavaServers(true, + "cacheserver_notify_subscription.xml", + "cacheserver_notify_subscription2.xml", + "cacheserver_notify_subscription3.xml"); + + CacheHelper.StartJavaLocator(1, "GFELOC"); + Util.Log("Locator started"); + + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + m_client1.Call(InitClient_Pool, CacheHelper.Locators, redundancyLevel); + m_client1.Call(CreateHATCRegions, RegionNames, false, + (string)null, useRegexes, true); + Util.Log("StepOne complete."); + + m_client2.Call(InitClient_Pool, CacheHelper.Locators, redundancyLevel); + m_client2.Call(CreateHATCRegions, RegionNames, false, + (string)null, !useRegexes, true); + Util.Log("StepTwo complete."); + + CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1); + Util.Log("Cacheserver 2 started."); + + if (redundancyLevel > 1) + { + if (useRegexes) + { + m_client2.Call(RegisterRegexesException, m_regexes[0], m_regexes[2]); + } + else + { + m_client2.Call(RegisterKeysException, m_keys[0], m_keys[2]); + } + } + else + { + if (useRegexes) + { + m_client2.Call(RegisterRegexes, m_regexes[0], m_regexes[2]); + } + else + { + m_client2.Call(RegisterKeys, m_keys[0], m_keys[2]); + } + } + Util.Log("RegisterKeys done."); + + m_client1.Call(CreateVals); + Util.Log("StepThree complete."); + + m_client2.Call(VerifyValCreations, true); + m_client2.Call(Verify2Vals, true); + m_client2.Call(DoNetsearch2Vals, false); + Util.Log("StepFour complete."); + + CacheHelper.StopJavaServer(1); + Util.Log("Cacheserver 1 stopped."); + //For Failover to complete. + Thread.Sleep(5000); + + m_client1.Call(CheckServerKeys); + m_client1.Call(UpdateNVals, true); + Thread.Sleep(1000); + Util.Log("StepFive complete."); + + m_client2.Call(VerifyNValsVals); + Util.Log("StepSix complete."); + + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + CacheHelper.StopJavaServer(2); + Util.Log("Cacheserver 2 stopped."); + + //For Failover to complete. + Thread.Sleep(5000); + + CacheHelper.StartJavaServerWithLocators(3, "GFECS3", 1); + Util.Log("Cacheserver 3 started."); + + m_client1.Call(UpdateVals); + Thread.Sleep(1000); + Util.Log("StepSeven complete."); + + m_client2.Call(VerifyVals); + if (useRegexes) + { + m_client2.Call(UnregisterRegexes, (string)null, m_regexes[2]); + } + else + { + m_client2.Call(UnregisterKeys, (string)null, m_keys[2]); + } + Util.Log("StepEight complete."); + + CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1); + Util.Log("Cacheserver 2 started."); + + CacheHelper.StopJavaServer(3); + Util.Log("Cacheserver 3 stopped."); + + m_client1.Call(UpdateNVals, true); + Thread.Sleep(1000); + Util.Log("StepNine complete."); + + m_client2.Call(VerifyNValVals); + Util.Log("StepTen complete."); + + CacheHelper.StopJavaServer(1); + Util.Log("Cacheserver 1 stopped."); + + //For Failover to complete. + Thread.Sleep(5000); + + m_client1.Call(UpdateVals); + Thread.Sleep(1000); + Util.Log("StepEleven complete."); + + m_client2.Call(VerifyVals); + Util.Log("StepTwelve complete."); + + m_client1.Call(Close); + m_client2.Call(Close); + + CacheHelper.StopJavaServer(2); + Util.Log("Cacheserver 2 stopped."); + + CacheHelper.StopJavaLocator(1); + Util.Log("Locator stopped"); + + CacheHelper.ClearEndpoints(); + CacheHelper.ClearLocators(); + } + + public void KillServer() + { + CacheHelper.StopJavaServer(1); + Util.Log("Cacheserver 1 stopped."); + } + + public delegate void KillServerDelegate(); + + public void StepOneFailover() + { + // This is here so that Client1 registers information of the cacheserver + // that has been already started + CacheHelper.SetupJavaServers(true, + "cacheserver_remoteoqlN.xml", + "cacheserver_remoteoql2N.xml"); + CacheHelper.StartJavaLocator(1, "GFELOC"); + Util.Log("Locator started"); + //CacheHelper.StartJavaServer(1, "GFECS1"); + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + try + { + Serializable.RegisterTypeGeneric(Portfolio.CreateDeserializable, CacheHelper.DCache); + Serializable.RegisterTypeGeneric(Position.CreateDeserializable, CacheHelper.DCache); + } + catch (IllegalStateException) + { + // ignored since we run multiple iterations for pool and non pool configs + } + + InitClient_Pool(CacheHelper.Locators, 1); + CacheHelper.CreateTCRegion_Pool<object, object>(QueryRegionName, true, true, + null, null, "__TESTPOOL1_", true); + + Region region = CacheHelper.GetVerifyRegion<object, object>(QueryRegionName); + Portfolio port1 = new Portfolio(1, 100); + Portfolio port2 = new Portfolio(2, 200); + Portfolio port3 = new Portfolio(3, 300); + Portfolio port4 = new Portfolio(4, 400); + + region["1"] = port1; + region["2"] = port2; + region["3"] = port3; + region["4"] = port4; + } + + public void StepTwoFailover() + { + CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1); + Util.Log("Cacheserver 2 started."); + + IAsyncResult killRes = null; + KillServerDelegate ksd = new KillServerDelegate(KillServer); + + QueryService<object, object> qs = null; + qs = CacheHelper.DCache.GetPoolManager().Find("__TESTPOOL1_").GetQueryService<object, object>(); + + for (int i = 0; i < 10000; i++) + { + Query<object> qry = qs.NewQuery("select distinct * from /" + QueryRegionName); + + ISelectResults<object> results = qry.Execute(); + + if (i == 10) + { + Util.Log("Starting the kill server thread."); + killRes = ksd.BeginInvoke(null, null); + } + + Int32 resultSize = results.Size; + + if (i % 100 == 0) + { + Util.Log("Iteration upto {0} done, result size is {1}", i, resultSize); + } + + Assert.AreEqual(4, resultSize, "Result size is not 4!"); + } + + killRes.AsyncWaitHandle.WaitOne(); + ksd.EndInvoke(killRes); + } + + #endregion + + void runDistOps() + { + CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription.xml", + "cacheserver_notify_subscription2.xml"); + + CacheHelper.StartJavaLocator(1, "GFELOC"); + + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1); + Util.Log("Cacheserver 2 started."); + + m_client1.Call(InitClient_Pool, CacheHelper.Locators, 1); + m_client2.Call(InitClient_Pool, CacheHelper.Locators, 1); + m_client1.Call(CreateNonExistentRegion, CacheHelper.Locators); + + DistOpsCommonSteps(true); + + m_client1.Call(Close); + m_client2.Call(Close); + + CacheHelper.StopJavaServer(1); + Util.Log("Cacheserver 1 stopped."); + + CacheHelper.StopJavaServer(2); + Util.Log("Cacheserver 2 stopped."); + + CacheHelper.StopJavaLocator(1); + Util.Log("Locator 1 stopped."); + } + + void runDistOpsXml() + { + + CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription.xml", + "cacheserver_notify_subscription2.xml"); + + CacheHelper.StartJavaLocator(1, "GFELOC"); + + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1); + Util.Log("Cacheserver 2 started."); + + m_client1.Call(InitClientXml, "client_pool.xml", CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2); + m_client2.Call(InitClientXml, "client_pool.xml", CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2); + + DistOpsCommonSteps(false); + + m_client1.Call(Close); + m_client2.Call(Close); + + CacheHelper.StopJavaServer(1); + Util.Log("Cacheserver 1 stopped."); + + CacheHelper.StopJavaServer(2); + Util.Log("Cacheserver 2 stopped."); + + CacheHelper.StopJavaLocator(1); + } + + void runGenericsXmlPlugins() + { + Util.Log("runGenericsXmlPlugins: pool with endpoints in client XML."); + + CacheHelper.SetupJavaServers(false, "cacheserver1_partitioned.xml", + "cacheserver2_partitioned.xml"); + + CacheHelper.StartJavaServer(1, "GFECS1"); + Util.Log("Cacheserver 1 started."); + + CacheHelper.StartJavaServer(2, "GFECS2"); + Util.Log("Cacheserver 2 started."); + + m_client1.Call(InitClientXml, "client_pool.xml", CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2); + m_client2.Call(InitClientXml, "client_generics_plugins.xml", CacheHelper.HOST_PORT_1, CacheHelper.HOST_PORT_2); + + m_client1.Call(CreateHATCRegions, RegionNames, false, + (string)null, false, false); + m_client2.Call(CreateHATCRegions, RegionNames, false, + (string)null, false, false); + Util.Log("StepOne complete."); + + m_client2.Call(RegisterKeys, m_keys[0], m_keys[2]); + + m_client1.Call(Create2Vals, true); + + m_client2.Call(DoCacheLoad2Vals, false); + + m_client1.Call(Update2NVals, true, true); + + m_client2.Call(Create2Vals, false); + + m_client2.Call(VerifyTallies); + + m_client1.Call(Close); + m_client2.Call(Close); + + CacheHelper.StopJavaServer(1); + Util.Log("Cacheserver 1 stopped."); + + CacheHelper.StopJavaServer(2); + Util.Log("Cacheserver 2 stopped."); + } + + void runQueryFailover() + { + try + { + m_client1.Call(StepOneFailover); + Util.Log("StepOneFailover complete."); + + m_client1.Call(StepTwoFailover); + Util.Log("StepTwoFailover complete."); + + m_client1.Call(Close); + Util.Log("Client closed"); + } + finally + { + m_client1.Call(CacheHelper.StopJavaServers); + m_client1.Call(CacheHelper.StopJavaLocator, 1); + Util.Log("Locator stopped"); + } + } + + void runPeriodicAck() + { + CacheHelper.SetupJavaServers(true, + "cacheserver_notify_subscription.xml", + "cacheserver_notify_subscription2.xml"); + + CacheHelper.StartJavaLocator(1, "GFELOC"); + Util.Log("Locator started"); + + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1); + Util.Log("Cacheserver 2 started."); + + m_client1.Call(InitClientForEventId_Pool, CacheHelper.Locators, false, 1, 10, 30); + + m_client1.Call(CreateHATCRegions, RegionNames, false, + (string)null, false, true); + Util.Log("StepOne complete."); + + m_client2.Call(InitClientForEventId_Pool, CacheHelper.Locators, true, 1, 10, 30); + m_client2.Call(CreateHATCRegions, RegionNames, false, + (string)null, true, true); + m_client2.Call(InitDupListeners); + Util.Log("StepTwo complete."); + + m_client1.Call(CreateEntriesForEventId, 50); + Util.Log("CreateEntries complete."); + + Thread.Sleep(30000); + + m_client2.Call(CheckClientForEventId); + Util.Log("CheckClient complete."); + + m_client1.Call(Close); + m_client2.Call(Close); + + CacheHelper.StopJavaServer(1); + Util.Log("Cacheserver 1 stopped."); + + CacheHelper.StopJavaServer(2); + Util.Log("Cacheserver 2 stopped."); + + CacheHelper.StopJavaLocator(1); + Util.Log("Locator stopped"); + } + + void runEventIDMap() + { + CacheHelper.SetupJavaServers(true, + "cacheserver_notify_subscription.xml", + "cacheserver_notify_subscription2.xml"); + + CacheHelper.StartJavaLocator(1, "GFELOC"); + Util.Log("Locator started"); + + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + m_client1.Call(InitClientForEventId_Pool, CacheHelper.Locators, false, 1, 3600, 3600); + m_client1.Call(CreateHATCRegions, RegionNames, false, + (string)null, false, true); + Util.Log("StepOne complete."); + + m_client2.Call(InitClientForEventId_Pool, CacheHelper.Locators, true, 1, 3600, 3600); + m_client2.Call(CreateHATCRegions, RegionNames, false, + (string)null, true, true); + m_client2.Call(InitDupListeners); + Util.Log("StepTwo complete."); + + CacheHelper.StartJavaServerWithLocators(2, "GFECS2", 1); + Util.Log("Cacheserver 2 started."); + + m_client1.Call(CreateEntriesForEventId, 10); + Util.Log("CreateEntries complete."); + + CacheHelper.StopJavaServer(1); + Util.Log("Cacheserver 1 stopped."); + + Thread.Sleep(30000); + + m_client2.Call(CheckClientForEventId); + Util.Log("CheckClient complete."); + + m_client1.Call(Close); + m_client2.Call(Close); + + CacheHelper.StopJavaServer(2); + Util.Log("Cacheserver 2 stopped."); + + CacheHelper.StopJavaLocator(1); + Util.Log("Locator stopped"); + } + + [Test] + public void DistOps() + { + runDistOps(); + } + + [Test] + public void DistOpsXml() + { + runDistOpsXml(); + } + + [Test] + public void GenericsXmlPlugins() + { + runGenericsXmlPlugins(); + } + + [Test] + public void FailoverR1() + { + FailoverCommonSteps(1, false); + } + + [Test] + public void FailoverR3() + { + FailoverCommonSteps(3, false); + } + + [Test] + public void FailoverRegexR1() + { + FailoverCommonSteps(1, true); + } + + [Test] + public void FailoverRegexR3() + { + FailoverCommonSteps(3, true); + } + + [Test] + public void QueryFailover() + { + runQueryFailover(); + } + + [Test] + public void PeriodicAck() + { + runPeriodicAck(); + } + + [Test] + public void EventIDMap() + { + runEventIDMap(); + } + + } +}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/6cbd424f/clicache/integration-test/ThinClientListenerWriterN.cs ---------------------------------------------------------------------- diff --git a/clicache/integration-test/ThinClientListenerWriterN.cs b/clicache/integration-test/ThinClientListenerWriterN.cs new file mode 100644 index 0000000..2a7ccfc --- /dev/null +++ b/clicache/integration-test/ThinClientListenerWriterN.cs @@ -0,0 +1,287 @@ +/* + * 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.Threading; + +namespace Apache.Geode.Client.UnitTests +{ + using NUnit.Framework; + using Apache.Geode.DUnitFramework; + using Apache.Geode.Client; + using Apache.Geode.Client.UnitTests; + using Region = Apache.Geode.Client.IRegion<Object, Object>; + + [TestFixture] + [Category("group1")] + [Category("unicast_only")] + [Category("generics")] + public class ThinClientListenerWriter : ThinClientRegionSteps + { + private TallyWriter<object, object> m_writer; + private TallyListener<object, object> m_listener; + RegionOperation o_region; + + private UnitProcess m_client1, m_client2, m_client3; + + protected override ClientBase[] GetClients() + { + m_client1 = new UnitProcess(); + m_client2 = new UnitProcess(); + m_client3 = new UnitProcess(); + return new ClientBase[] { m_client1, m_client2, m_client3 }; + } + + public void CreateRegion(string locators, + bool caching, bool listener, bool writer) + { + if (listener) + { + m_listener = new TallyListener<object, object>(); + } + else + { + m_listener = null; + } + Region region = null; + region = CacheHelper.CreateTCRegion_Pool<object, object>(RegionName, true, caching, + m_listener, locators, "__TESTPOOL1_", true); + + if (writer) + { + m_writer = new TallyWriter<object, object>(); + AttributesMutator<object, object> at = region.AttributesMutator; + at.SetCacheWriter(m_writer); + } + + } + + public void ValidateEvents() + { + Thread.Sleep(5000); + m_listener.ShowTallies(); + m_writer.ShowTallies(); + Assert.AreEqual(0, m_listener.Creates, "Should be 0 creates"); + Assert.AreEqual(0, m_listener.Updates, "Should be 0 updates"); + Assert.AreEqual(20, m_listener.Invalidates, "Should be 20 invalidates"); + Assert.AreEqual(5, m_listener.Destroys, "Should be 5 destroys"); + Assert.AreEqual(false, m_writer.IsWriterInvoked, "Writer Should not be invoked"); + } + + public void ValidateGetEvents(int creates, int updates) + { + Thread.Sleep(1000); + m_listener.ShowTallies(); + Assert.AreEqual(creates, m_listener.Creates, "Incorrect creates"); + Assert.AreEqual(updates, m_listener.Updates, "Incorrect updates"); + } + + public void ValidateListenerWriterWithNBSTrue() + { + Thread.Sleep(5000); + m_listener.ShowTallies(); + + Assert.AreEqual(10, m_listener.Creates, "Should be 10 creates"); + Assert.AreEqual(10, m_listener.Updates, "Should be 10 updates"); + Assert.AreEqual(0, m_listener.Invalidates, "Should be 0 invalidates"); + Assert.AreEqual(5, m_listener.Destroys, "Should be 5 destroys"); + Assert.AreEqual(false, m_writer.IsWriterInvoked, "Writer should not be invoked"); + } + + public void RegisterAllKeysRN() + { + Region region = CacheHelper.GetVerifyRegion<object, object>(RegionName); + region.GetSubscriptionService().RegisterAllKeys(false, null, false, false); + } + + public void CallOp() + { + o_region = new RegionOperation(RegionName); + o_region.PutOp(5, null); + Thread.Sleep(1000); // let the events reach at other end. + o_region.PutOp(5, null); + Thread.Sleep(1000); + o_region.InvalidateOp(5, null); + Thread.Sleep(1000); + o_region.DestroyOp(5, null); + Thread.Sleep(1000); + } + + public void PutOp(string key, string value) + { + Util.Log("PutOp started"); + o_region = new RegionOperation(RegionName); + Region r = o_region.Region; + r[key] = value; + Thread.Sleep(1000); // let the events reach at other end. + Util.Log("PutOp finished"); + } + + public void InvalidateOp(string key) + { + Util.Log("InvalidateOp started"); + o_region = new RegionOperation(RegionName); + Region r = o_region.Region; + r.GetLocalView().Invalidate(key); + Thread.Sleep(1000); // let the events reach at other end. + Util.Log("InvalidateOp finished"); + } + + public void GetOp(string key) + { + Util.Log("GetOp started"); + o_region = new RegionOperation(RegionName); + Region r = o_region.Region; + Object val = r[key]; + Thread.Sleep(1000); // let the events reach at other end. + Util.Log("GetOp finished"); + } + + public void registerPdxType8() + { + Serializable.RegisterPdxType(PdxTests.PdxTypes8.CreateDeserializable); + } + void runThinClientListenerWriterTest() + { + CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription.xml"); + CacheHelper.StartJavaLocator(1, "GFELOC"); + Util.Log("Locator started"); + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + m_client1.Call(CacheHelper.InitClient); + Util.Log("Creating region in client1, no-ack, no-cache, no-listener and no-writer"); + m_client1.Call(CreateRegion, CacheHelper.Locators, + false, false, false); + + m_client2.Call(CacheHelper.InitClient); + Util.Log("Creating region in client2 , no-ack, no-cache, with listener and writer"); + m_client2.Call(CreateRegion, CacheHelper.Locators, + false, true, true); + + m_client1.Call(registerPdxType8); + m_client2.Call(registerPdxType8); + + m_client2.Call(RegisterAllKeys, new string[] { RegionName }); + + m_client1.Call(CallOp); + + m_client2.Call(ValidateListenerWriterWithNBSTrue); + + m_client1.Call(CacheHelper.CloseCache); + + m_client2.Call(CacheHelper.CloseCache); + + CacheHelper.StopJavaServer(1); + + CacheHelper.SetupJavaServers(true, "cacheserver.xml"); + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + Util.Log("Creating region in client1, no-ack, no-cache, no-listener and no-writer"); + m_client1.Call(CreateRegion, CacheHelper.Locators, + false, false, false); + + Util.Log("Creating region in client2 , no-ack, no-cache, with listener and writer"); + m_client2.Call(CreateRegion, CacheHelper.Locators, + false, true, true); + + m_client3.Call(CacheHelper.InitClient); + Util.Log("Creating region in client2 , no-ack, no-cache, with listener and writer"); + m_client3.Call(CreateRegion, CacheHelper.Locators, + false, true, true); + + m_client1.Call(registerPdxType8); + m_client2.Call(registerPdxType8); + + m_client2.Call(RegisterAllKeysRN); + + m_client3.Call(RegisterAllKeysRN); + + m_client1.Call(CallOp); + + m_client2.Call(ValidateEvents); + + m_client3.Call(ValidateEvents); + + m_client1.Call(CacheHelper.Close); + m_client2.Call(CacheHelper.Close); + m_client3.Call(CacheHelper.Close); + + CacheHelper.StopJavaServer(1); + + /* Bug #381 */ + CacheHelper.SetupJavaServers(true, "cacheserver.xml"); + CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1); + Util.Log("Cacheserver 1 started."); + + Util.Log("Creating region in client1, no-ack, no-cache, no-listener and no-writer"); + m_client1.Call(CreateRegion,CacheHelper.Locators, + false, false, false); + + Util.Log("Creating region in client2 , with listener and writer"); + m_client2.Call(CreateRegion, CacheHelper.Locators, + true, true, true); + + m_client3.Call(CacheHelper.InitClient); + Util.Log("Creating region in client3 , with listener and writer"); + m_client3.Call(CreateRegion, CacheHelper.Locators, + true, true, true); + + m_client2.Call(RegisterAllKeysRN); + m_client1.Call(PutOp, "Key-1", "Value-1"); + m_client2.Call(GetOp, "Key-1"); + m_client2.Call(ValidateGetEvents, 0, 1); + Util.Log("ValidateGetEvents 1 done. "); + + m_client3.Call(RegisterAllKeysRN); + m_client3.Call(GetOp, "Key-1"); + m_client3.Call(ValidateGetEvents, 1, 0); + Util.Log("ValidateGetEvents 2 done. "); + + m_client2.Call(PutOp, "Key-2", "Value-2"); + m_client2.Call(InvalidateOp, "Key-2"); + m_client2.Call(GetOp, "Key-2"); + m_client2.Call(ValidateGetEvents, 1, 2); + Util.Log("ValidateGetEvents 3 done. "); + + m_client1.Call(CacheHelper.Close); + m_client2.Call(CacheHelper.Close); + m_client3.Call(CacheHelper.Close); + + CacheHelper.StopJavaServer(1); + + CacheHelper.StopJavaLocator(1); + Util.Log("Locator stopped"); + + CacheHelper.ClearLocators(); + CacheHelper.ClearEndpoints(); + } + + [TearDown] + public override void EndTest() + { + base.EndTest(); + } + + [Test] + public void ThinClientListenerWriterTest() + { + runThinClientListenerWriterTest(); + } + } +}
