clicache/integration-test/ThinClientCallbackArgN.cs

/*
 * 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.Tests;

  using Apache.Geode.Client;

  using GIRegion = Apache.Geode.Client.IRegion<int, object>;
  using System.Collections.Generic;

  public class CallbackListener : CacheListenerAdapter<int, object>
  {
    int m_creates;
    int m_updates;
    int m_invalidates;
    int m_destroys;
    int m_regionInvalidate;
    int m_regionDestroy;
    int m_regionClear; 
    object m_callbackArg;

    #region Getters

    public int Creates
    {
      get { return m_creates; }
    }

    public int Updates
    {
      get { return m_updates; }
    }

    public int Invalidates
    {
      get { return m_invalidates; }
    }

    public int Destroys
    {
      get { return m_destroys; }
    }

    public int RegionInvalidates
    {
      get { return m_regionInvalidate; }
    }

    public int RegionDestroys
    {
      get { return m_regionDestroy; }
    }
    public int RegionClear
 	{ 
 	  get { return m_regionClear; }
 	}
    public object CallbackArg
    {
      get { return m_callbackArg; }
    }
    #endregion

    public void SetCallbackArg(object callbackArg)
    {
      m_callbackArg = callbackArg;
    }

    private void check(object eventCallback, ref int updateCount)
    {
      Log.Fine("check..");
      if (eventCallback != null)
      {
        string callbackArg = eventCallback as string;

        if (callbackArg != null)
        {
          string cs = m_callbackArg as string;
          if (cs != null)
          {
            if (callbackArg == cs)
            {
              Log.Fine("value matched");
              updateCount++;
            }
            else
              Log.Fine("value matched NOT");
          }
        }
        else
        {
          Log.Fine("Callbackarg is not cacheable string");
          Portfolio pfCallback = eventCallback as Portfolio;
          if (pfCallback != null)
          {
            Portfolio pf = m_callbackArg as Portfolio;
            if (pf != null)
            {
              if (pf.Pkid == pfCallback.Pkid && pfCallback.ArrayNull == null
                    && pfCallback.ArrayZeroSize != null && pfCallback.ArrayZeroSize.Length == 0)
              {
                Log.Fine("value matched");
                updateCount++;
              }
            }
          }
        }
      }
    }

    private void checkCallbackArg(EntryEvent<int, object> entryEvent, ref int updateCount)
    {
      check(entryEvent.CallbackArgument, ref updateCount);
    }

    private void checkCallbackArg(RegionEvent<int, object> regionEvent, ref int updateCount)
    {
      check(regionEvent.CallbackArgument, ref updateCount);
    }

    #region CacheListener Members

    public override void AfterCreate(EntryEvent<int, object> ev)
    {
      checkCallbackArg(ev, ref m_creates);
    }

    public override void AfterUpdate(EntryEvent<int, object> ev)
    {
      checkCallbackArg(ev, ref m_updates);
    }

    public override void AfterInvalidate(EntryEvent<int, object> ev)
    {
      checkCallbackArg(ev, ref m_invalidates);
    }

    public override void AfterDestroy(EntryEvent<int, object> ev)
    {
      checkCallbackArg(ev, ref m_destroys);
    }

    public override void AfterRegionInvalidate(RegionEvent<int, object> rev)
    {
      checkCallbackArg(rev, ref m_regionInvalidate);
    }

    public override void AfterRegionDestroy(RegionEvent<int, object> rev)
    {
      checkCallbackArg(rev, ref m_regionDestroy);
    }
    public override void AfterRegionClear(RegionEvent<int, object> rev)
    {
        checkCallbackArg(rev, ref m_regionClear);
    }

    #endregion
  }

  [TestFixture]
  [Category("generics")]
  public class ThinClientCallbackArg : ThinClientRegionSteps
  {
    private TallyWriter<int, object> m_writer;
    private TallyListener<int, object> m_listener;
    private CallbackListener m_callbackListener;
    RegionOperation o_region;
    private UnitProcess m_client1, m_client2;
    int key0 = 12;
    object m_callbackarg = "Gemstone's Callback";
    
    protected override ClientBase[] GetClients()
    {
      m_client1 = new UnitProcess();
      m_client2 = new UnitProcess();
      return new ClientBase[] { m_client1, m_client2 };
    }

    public void CreateRegion(string locators,
      bool caching, bool listener, bool writer)
    {
      if (listener)
      {
        m_listener = new TallyListener<int, object>();

      }
      else
      {
        m_listener = null;
      }
      GIRegion region = null;
      region = CacheHelper.CreateTCRegion_Pool<int, object>(RegionName, true, caching,
        m_listener, locators, "__TESTPOOL1_", true);
      if (listener)
        m_listener.SetCallBackArg(key0);

      if (writer)
      {
        m_writer = new TallyWriter<int, object>();

      }
      else
      {
        m_writer = null;
      }
      if (writer)
      {
        AttributesMutator<int, object> at = region.AttributesMutator;
        at.SetCacheWriter(m_writer);
        m_writer.SetCallBackArg(key0);
      }
    }

    public void CreateRegion2(string locators,
      bool caching, bool listener, bool writer)
    {
      CallbackListener callbackLis = null;
      if (listener)
      {
        m_callbackListener = new CallbackListener();
        m_callbackListener.SetCallbackArg(m_callbackarg);
        callbackLis = m_callbackListener;
      }
      else
      {
        m_listener = null;
      }
      GIRegion region = null;
      region = CacheHelper.CreateTCRegion_Pool<int, object>(RegionName, true, caching,
        callbackLis, locators, "__TESTPOOL1_", true);
      CacheHelper.DCache.TypeRegistry.RegisterType(Portfolio.CreateDeserializable, 8);
      CacheHelper.DCache.TypeRegistry.RegisterType(Position.CreateDeserializable, 7);
    }

    public void ValidateLocalListenerWriterData()
    {
      Thread.Sleep(2000);
      Assert.AreEqual(true, m_writer.IsWriterInvoked, "Writer should be invoked");
      Assert.AreEqual(true, m_listener.IsListenerInvoked, "Listener should be invoked");
      Assert.AreEqual(true, m_writer.IsCallBackArgCalled, "Writer CallbackArg should be invoked");
      Assert.AreEqual(true, m_listener.IsCallBackArgCalled, "Listener CallbackArg should be invoked");
      m_listener.ShowTallies();
      m_writer.ShowTallies();
    }

    public void ValidateEvents()
    {
      Assert.AreEqual(15, m_writer.Creates, "Should be 10 creates");
      Assert.AreEqual(15, m_listener.Creates, "Should be 10 creates");
      Assert.AreEqual(15, m_writer.Updates, "Should be 5 updates");
      Assert.AreEqual(15, m_listener.Updates, "Should be 5 updates");
      Assert.AreEqual(0, m_writer.Invalidates, "Should be 0 invalidates");
      Assert.AreEqual(5, m_listener.Invalidates, "Should be 5 invalidates");
      Assert.AreEqual(10, m_writer.Destroys, "Should be 10 destroys");  // 5 destroys + 5 removes
      Assert.AreEqual(10, m_listener.Destroys, "Should be 10 destroys"); // 5 destroys + 5 removes
    }

    public void CallOp()
    {
      o_region = new RegionOperation(RegionName);
      o_region.PutOp(5, key0);
      Thread.Sleep(1000); // let the events reach at other end.
      o_region.PutOp(5, key0);
      Thread.Sleep(1000);
      o_region.InvalidateOp(5, key0);
      Thread.Sleep(1000);
      o_region.DestroyOp(5, key0);
      Thread.Sleep(1000); // let the events reach at other end.
      o_region.PutOp(5, key0);
      Thread.Sleep(1000);
      o_region.RemoveOp(5, key0);
      Thread.Sleep(1000);
    }

    void RegisterPdxType8()
    {
      CacheHelper.DCache.TypeRegistry.RegisterPdxType(PdxTests.PdxTypes8.CreateDeserializable);
    }

    void runCallbackArgTest()
    {
      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.");

      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
      m_client1.Call(CreateRegion, CacheHelper.Locators,
        true, true, true);
      m_client1.Call(RegisterAllKeys, new string[] { RegionName });

      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
      m_client2.Call(CreateRegion, CacheHelper.Locators,
        true, true, true);
      m_client2.Call(RegisterAllKeys, new string[] { RegionName });

      m_client2.Call(RegisterPdxType8);

      m_client1.Call(CallOp);
      

      m_client1.Call(ValidateLocalListenerWriterData);
      m_client1.Call(ValidateEvents);

      m_client1.Call(CacheHelper.Close);
      m_client2.Call(CacheHelper.Close);

      CacheHelper.StopJavaServer(1);
      Util.Log("Cacheserver 1 stopped.");

      CacheHelper.StopJavaLocator(1);
      Util.Log("Locator stopped");

      CacheHelper.ClearLocators();
      CacheHelper.ClearEndpoints();
    }

    private bool m_isSet = false;
    public void SetCallbackArg()
    {
      if (!m_isSet)
      {
        m_isSet = true;
        m_callbackarg = new Portfolio(1, 1);
      }
    }

    public void TestCreatesAndUpdates()
    {
      o_region = new RegionOperation(RegionName);
      o_region.Region.Add("Key-1", "Val-1", m_callbackarg);
      o_region.Region.Put("Key-1", "NewVal-1", m_callbackarg);
      Thread.Sleep(10000);
    }

    public void TestInvalidates()
    {
      o_region = new RegionOperation(RegionName);
      o_region.Region.GetLocalView().Add(1234, 1234, m_callbackarg);
      o_region.Region.GetLocalView().Add(12345, 12345, m_callbackarg);
      o_region.Region.GetLocalView().Add(12346, 12346, m_callbackarg);
      o_region.Region.GetLocalView().Put(1234, "Val-1", m_callbackarg);
      o_region.Region.GetLocalView().Invalidate(1234, m_callbackarg);
      Assert.AreEqual(o_region.Region.GetLocalView().Remove(12345, 12345, m_callbackarg), true, "Result of remove should be true, as this value exists locally.");
      Assert.AreEqual(o_region.Region.GetLocalView().ContainsKey(12345), false, "containsKey should be false");
      Assert.AreEqual(o_region.Region.GetLocalView().Remove(12346, m_callbackarg), true, "Result of remove should be true, as this value exists locally.");
      Assert.AreEqual(o_region.Region.GetLocalView().ContainsKey(12346), false, "containsKey should be false"); 
      o_region.Region.Invalidate("Key-1", m_callbackarg);
      o_region.Region.InvalidateRegion(m_callbackarg);
    }

    public void TestDestroy()
    {
      o_region = new RegionOperation(RegionName);
      o_region.Region.Remove("Key-1", m_callbackarg);
      //o_region.Region.DestroyRegion(m_callbackarg);
    }

    public void TestRemove()
    {
      o_region = new RegionOperation(RegionName);
      o_region.Region.Remove("Key-1", "NewVal-1", m_callbackarg);
      o_region.Region.DestroyRegion(m_callbackarg);
    }

    public void TestlocalClear()
    {
        o_region = new RegionOperation(RegionName);
        o_region.Region.GetLocalView().Clear(m_callbackarg); 
    }
    public void TestValidate()
    {
      Thread.Sleep(10000);
      Assert.AreEqual(5, m_callbackListener.Creates, "Should be 5 creates");
      Assert.AreEqual(3, m_callbackListener.Updates, "Should be 3 update");
      Assert.AreEqual(2, m_callbackListener.Invalidates, "Should be 2 invalidate");
      Assert.AreEqual(4, m_callbackListener.Destroys, "Should be 4 destroy");
      Assert.AreEqual(1, m_callbackListener.RegionInvalidates, "Should be 1 region invalidates");
      Assert.AreEqual(1, m_callbackListener.RegionDestroys, "Should be 1 regiondestroy");
      Assert.AreEqual(1, m_callbackListener.RegionClear, "Should be 1 RegionClear");
    }

    void runCallbackArgTest2(int callbackArgChange)
    {
      if (callbackArgChange == 1)
      {
        //change now custom type
        m_callbackarg = new Portfolio(1, 1);
        m_client1.Call(SetCallbackArg);
        m_client2.Call(SetCallbackArg);
      }

      m_callbackListener = new CallbackListener();
      m_callbackListener.SetCallbackArg(m_callbackarg);
      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription5N.xml");
      CacheHelper.StartJavaLocator(1, "GFELOC");
      Util.Log("Locator started");
      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
      Util.Log("Cacheserver 1 started.");

      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
      m_client1.Call(CreateRegion2, CacheHelper.Locators,
        true, true, false);
      m_client1.Call(RegisterAllKeys, new string[] { RegionName });

      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
      m_client2.Call(CreateRegion2, CacheHelper.Locators,
        true, false, false);

      m_client2.Call(TestCreatesAndUpdates);
      m_client1.Call(TestInvalidates);
      m_client2.Call(TestDestroy);
      m_client2.Call(TestCreatesAndUpdates);
      m_client1.Call(TestlocalClear); 
      m_client2.Call(TestRemove);
      m_client1.Call(TestValidate);

      m_client1.Call(CacheHelper.Close);
      m_client2.Call(CacheHelper.Close);

      CacheHelper.StopJavaServer(1);
      Util.Log("Cacheserver 1 stopped.");

      CacheHelper.StopJavaLocator(1);
      Util.Log("Locator stopped");

      CacheHelper.ClearLocators();
      CacheHelper.ClearEndpoints();
    }

    private bool isRegistered = false;
    public void registerDefaultCacheableType()
    {
      if (!isRegistered)
      {
        CacheHelper.DCache.TypeRegistry.RegisterType(DefaultType.CreateDeserializable, 4);
        isRegistered = true;
      }
    }


    public void CallOp2()
    {
      o_region = new RegionOperation(RegionName);
      DefaultType dc = new DefaultType(true);
      o_region.Region.Put("key-1", dc, null);
      Thread.Sleep(1000); // let the events reach at other end.
    }

    public void ValidateData()
    {
      o_region = new RegionOperation(RegionName);
      DefaultType dc = (DefaultType)o_region.Region.Get("key-1", null);

      Assert.AreEqual(dc.CBool, true, "bool is not equal");
      Assert.AreEqual(dc.CInt, 1000, "int is not equal");

      int[] cia = dc.CIntArray;
      Assert.IsNotNull(cia, "Int array is null");
      Assert.AreEqual(3, cia.Length, "Int array are not three");

      string[] csa = dc.CStringArray;
      Assert.IsNotNull(csa, "String array is null");
      Assert.AreEqual(2, csa.Length, "String array length is not two");

      Assert.AreEqual(dc.CFileName, "geode.txt", "Cacheable filename is not equal");

      /*
      Assert.IsNotNull(dc.CHashSet, "hashset is null");
      Assert.AreEqual(2, dc.CHashSet.Count, "hashset size is not two");
       * */

      Assert.IsNotNull(dc.CHashMap, "hashmap is null");
      Assert.AreEqual(1, dc.CHashMap.Count, "hashmap size is not one");

      //Assert.IsNotNull(dc.CDate, "Date is null");

      Assert.IsNotNull(dc.CVector);
      Assert.AreEqual(2, dc.CVector.Count, "Vector size is not two");

      //Assert.IsNotNull(dc.CObject);
      //Assert.AreEqual("key", ((CustomSerializableObject)dc.CObject).key, "Object key is not same");
      //Assert.AreEqual("value", ((CustomSerializableObject)dc.CObject).value, "Object value is not same");
    }

    void runCallbackArgTest3()
    {

      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription6.xml");
      CacheHelper.StartJavaLocator(1, "GFELOC");
      Util.Log("Locator started");
      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
      Util.Log("Cacheserver 1 started.");

      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
      m_client1.Call(CreateRegion, CacheHelper.Locators,
        true, false, false);
      // m_client1.Call(RegisterAllKeys, new string[] { RegionName });

      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
      m_client2.Call(CreateRegion, CacheHelper.Locators,
        true, false, false);

      m_client1.Call(registerDefaultCacheableType);
      m_client2.Call(registerDefaultCacheableType);

      m_client2.Call(RegisterAllKeys, new string[] { RegionName });

      m_client1.Call(CallOp2);

      m_client2.Call(ValidateData);

      m_client1.Call(CacheHelper.Close);
      m_client2.Call(CacheHelper.Close);

      CacheHelper.StopJavaServer(1);
      Util.Log("Cacheserver 1 stopped.");

      CacheHelper.StopJavaLocator(1);
      Util.Log("Locator stopped");

      CacheHelper.ClearLocators();
      CacheHelper.ClearEndpoints();
    }

    public void TestRemoveAll()
    {
      o_region = new RegionOperation(RegionName);
      ICollection<object> keys = new LinkedList<object>(); 
      for(int i =0; i< 10; i++)
      {
        o_region.Region["Key-"+i] = "Value-"+i;
        keys.Add("Key-" + i);
      }
      o_region.Region.RemoveAll(keys, m_callbackarg);
    }

    public void TestPutAll()
    {
      o_region = new RegionOperation(RegionName);
      Dictionary<Object, Object> entryMap = new Dictionary<Object, Object>();
      for (Int32 item = 0; item < 10; item++)
      {
        int K = item;
        string value = item.ToString();
        entryMap.Add(K, value);
      }
      o_region.Region.PutAll(entryMap, TimeSpan.FromSeconds(15), m_callbackarg);
    }

    public void TestGetAll()
    {
      o_region = new RegionOperation(RegionName);
      List<Object> keys = new List<Object>();
      for (int item = 0; item < 10; item++)
      {
        Object K = item;
        keys.Add(K);
      }
      Dictionary<Object, Object> values = new Dictionary<Object, Object>();
      o_region.Region.GetAll(keys.ToArray(), values, null, true, m_callbackarg);

      Dictionary<Object, Object>.Enumerator enumerator = values.GetEnumerator();
      while (enumerator.MoveNext())
      {
        Util.Log("Values after getAll with CallBack Key = {0} Value = {1} ", enumerator.Current.Key.ToString(), enumerator.Current.Value.ToString());
      }
    }

    public void TestValidateRemoveAllCallback()
    {
      Thread.Sleep(10000);
      Assert.AreEqual(10, m_callbackListener.Destroys, "Should be 10 destroy");
    }

    public void TestValidatePutAllCallback()
    {
      Thread.Sleep(10000);
      Assert.AreEqual(10, m_callbackListener.Creates, "Should be 10 creates");      
      Assert.AreEqual("Gemstone's Callback", m_callbackListener.CallbackArg, "CallBackArg for putAll should be same");
    }

    void runPutAllCallbackArgTest()
    {
      m_callbackListener = new CallbackListener();
      m_callbackListener.SetCallbackArg(m_callbackarg);
      
      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription5N.xml");
      CacheHelper.StartJavaLocator(1, "GFELOC");
      Util.Log("Locator started");
      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
      Util.Log("Cacheserver 1 started.");

      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
      m_client1.Call(CreateRegion2, CacheHelper.Locators,
        true, true, false);
      m_client1.Call(RegisterAllKeys, new string[] { RegionName });
      Util.Log("RegisterAllKeys completed..");

      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
      m_client2.Call(CreateRegion2, CacheHelper.Locators,
        true, false, false);
      Util.Log("CreateRegion2 completed..");

      m_client2.Call(TestPutAll);
      Util.Log("TestPutAll completed..");
      m_client1.Call(TestValidatePutAllCallback);
      Util.Log("TestValidatePutAllCallback completed..");
      m_client2.Call(TestGetAll);
      Util.Log("TestGetAll completed..");

      m_client1.Call(CacheHelper.Close);
      m_client2.Call(CacheHelper.Close);

      CacheHelper.StopJavaServer(1);
      Util.Log("Cacheserver 1 stopped.");

      CacheHelper.StopJavaLocator(1);
      Util.Log("Locator stopped");

      CacheHelper.ClearLocators();
      CacheHelper.ClearEndpoints();
    }

    void runRemoveAllCallbackArgTest()
    {

      m_callbackListener = new CallbackListener();
      m_callbackListener.SetCallbackArg(m_callbackarg);
      CacheHelper.SetupJavaServers(true, "cacheserver_notify_subscription5N.xml");
      CacheHelper.StartJavaLocator(1, "GFELOC");
      Util.Log("Locator started");
      CacheHelper.StartJavaServerWithLocators(1, "GFECS1", 1);
      Util.Log("Cacheserver 1 started.");

      Util.Log("Creating region in client1, no-ack, cache-enabled, with listener and writer");
      m_client1.Call(CreateRegion2, CacheHelper.Locators,
        true, true, false);
      m_client1.Call(RegisterAllKeys, new string[] { RegionName });
      Util.Log("RegisterAllKeys completed..");

      Util.Log("Creating region in client2 , no-ack, cache-enabled, with listener and writer");
      m_client2.Call(CreateRegion2,CacheHelper.Locators,
        true, false, false);
      Util.Log("CreateRegion2 completed..");

      m_client2.Call(TestRemoveAll);
      Util.Log("TestRemoveAll completed..");
      m_client1.Call(TestValidateRemoveAllCallback);
      Util.Log("TestValidateRemoveAllCallback completed..");

      m_client1.Call(CacheHelper.Close);
      m_client2.Call(CacheHelper.Close);

      CacheHelper.StopJavaServer(1);
      Util.Log("Cacheserver 1 stopped.");

      CacheHelper.StopJavaLocator(1);
      Util.Log("Locator stopped");

      CacheHelper.ClearLocators();
      CacheHelper.ClearEndpoints();
    }

    [TearDown]
    public override void EndTest()
    {
      base.EndTest();
    }

    [Test]
    public void ThinClientCallbackArgTest()
    {
      runCallbackArgTest();
    }

    [Test]
    public void ThinClientCallbackArgTest2()
    {
      for (int i = 0; i < 2; i++)
      {
        runCallbackArgTest2(i);
      }
    }

    [Test]
    public void ThinClientCallbackArgTest3()
    {
      runCallbackArgTest3();
    }

    [Test]
    public void RemoveAllCallbackArgTest()
    {
      runRemoveAllCallbackArgTest();
    }

    [Test]
    public void PutAllCallbackArgTest()
    {
      runPutAllCallbackArgTest();
    }
  }
}