tests/cli/FwkUtil/FwkData.cs - geode-native - Git at Google

 /*
  * 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;
 using System.Collections.Generic;
 using System.Runtime.Serialization;
 using System.Xml;


 #pragma warning disable 618

 namespace Apache.Geode.Client.FwkLib
 {
   using Apache.Geode.DUnitFramework;
   using Apache.Geode.Client.Tests;

   [Serializable]
   public enum DataKind
   {
     String,
     List,
     Region,
     Range,
     Pool
   }

   [Serializable]
   public class FwkLocalFile
   {
     private string m_name;
     private bool m_append;
     private string m_description;
     private string m_content;

     #region Public accessors

     public string Name
     {
       get
       {
         return m_name;
       }
     }

     public bool Append
     {
       get
       {
         return m_append;
       }
     }

     public string Description
     {
       get
       {
         return m_description;
       }
     }

     public string Content
     {
       get
       {
         return m_content;
       }
     }

     #endregion

     public FwkLocalFile(string name, bool append, string description, string content)
     {
       m_name = name;
       m_append = append;
       m_description = description;
       m_content = content;
     }

     public static void LoadLocalFileNodes(XmlNode node)
     {
       XmlNodeList xmlNodes = node.SelectNodes("localFile");
       if (xmlNodes != null)
       {
         foreach (XmlNode lf in xmlNodes)
         {
           XmlAttributeCollection attrcoll = lf.Attributes;
           string name = null;
           bool append = false; ;
           string description = null;
           foreach (XmlAttribute attr in attrcoll)
           {
             // Console.WriteLine("attr name " + attr.Name);
             if (attr.Name == "name")
             {
               name = attr.Name;
             }
             else if (attr.Name == "append")
             {
               if (attr.Value == "true")
               {
                 append = true;
               }
               else
               {
                 append = false;
               }
             }
             else if (attr.Name == "description")
             {
               description = attr.Value;
             }
             else
             {
               throw new IllegalArgException("Local file data format incorrect");
             }
           }
           FwkLocalFile lfobj = new FwkLocalFile(name, append, description, lf.InnerText);
           Util.BBSet(string.Empty, name, lfobj);
         }
       }
     }
   }

   [Serializable]
   public class FwkData
   {
     #region Private members

     private object m_data1;
     private object m_data2;
     private DataKind m_kind;

     #endregion

     #region Public accessors

     public DataKind Kind
     {
       get
       {
         return m_kind;
       }
     }

     public object Data1
     {
       get
       {
         return m_data1;
       }
       set
       {
         m_data1 = value;
       }
     }
     public object Data2
     {
       get
       {
         return m_data2;
       }
       set
       {
         m_data2 = null;
       }
     }
     #endregion

     public FwkData(object data1, object data2, DataKind kind)
     {
       m_data1 = data1;
       m_data2 = data2;
       m_kind = kind;
     }

     public static Dictionary<string, FwkData> ReadDataNodes(XmlNode node)
     {
     throw new Exception();

     }

     public static void SetThisAttribute(string name, XmlNode node, Apache.Geode.Client.RegionAttributesFactory<string, string> regionAttributesFactory)
     {
       string value = node.Value;
       switch (name)
       {
         case "caching-enabled":
           if (value == "true")
           {
             regionAttributesFactory.SetCachingEnabled(true);
           }
           else
           {
             regionAttributesFactory.SetCachingEnabled(false);
           }
           break;

         case "load-factor":
           float lf = float.Parse(value);
           regionAttributesFactory.SetLoadFactor(lf);
           break;

         case "concurrency-level":
           int cl = int.Parse(value);
           regionAttributesFactory.SetConcurrencyLevel(cl);
           break;

         case "lru-entries-limit":
           uint lel = uint.Parse(value);
           regionAttributesFactory.SetLruEntriesLimit(lel);
           break;

         case "initial-capacity":
           int ic = int.Parse(value);
           regionAttributesFactory.SetInitialCapacity(ic);
           break;

         case "disk-policy":
           if (value == "none")
           {
               regionAttributesFactory.SetDiskPolicy(Apache.Geode.Client.DiskPolicyType.None);
           }
           else if (value == "overflows")
           {
               regionAttributesFactory.SetDiskPolicy(Apache.Geode.Client.DiskPolicyType.Overflows);
           }
           else
           {
             throw new IllegalArgException("Unknown disk policy");
           }
           break;
         case "pool-name":
           if (value.Length != 0)
           {
             regionAttributesFactory.SetPoolName(value);
           }
           else
           {
             regionAttributesFactory.SetPoolName(value);
           }
           break;

         case "client-notification":
           break;

         case "region-time-to-live":
           XmlNode nlrttl = node.FirstChild;
           if (nlrttl.Name == "expiration-attributes")
           {
             XmlAttributeCollection exAttrColl = nlrttl.Attributes;
             Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
             string rttl = exAttrColl["timeout"].Value;
             regionAttributesFactory.SetRegionTimeToLive(action, TimeSpan.FromSeconds(uint.Parse(rttl)));
           }
           else
           {
             throw new IllegalArgException("The xml file passed has an unknowk format");
           }
           break;

         case "region-idle-time":
           XmlNode nlrit = node.FirstChild;
           if (nlrit.Name == "expiration-attributes")
           {
             XmlAttributeCollection exAttrColl = nlrit.Attributes;
             Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
             string rit = exAttrColl["timeout"].Value;
             regionAttributesFactory.SetRegionIdleTimeout(action, TimeSpan.FromSeconds(uint.Parse(rit)));
           }
           else
           {
             throw new IllegalArgException("The xml file passed has an unknowk format");
           }
           break;

         case "entry-time-to-live":
           XmlNode nlettl = node.FirstChild;
           if (nlettl.Name == "expiration-attributes")
           {
             XmlAttributeCollection exAttrColl = nlettl.Attributes;
             Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
             string ettl = exAttrColl["timeout"].Value;
             regionAttributesFactory.SetEntryTimeToLive(action, TimeSpan.FromSeconds(uint.Parse(ettl)));
           }
           else
           {
             throw new IllegalArgException("The xml file passed has an unknowk format");
           }
           break;

         case "entry-idle-time":
           XmlNode nleit = node.FirstChild;
           if (nleit.Name == "expiration-attributes")
           {
             XmlAttributeCollection exAttrColl = nleit.Attributes;
             Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
             string eit = exAttrColl["timeout"].Value;
             regionAttributesFactory.SetEntryIdleTimeout(action, TimeSpan.FromSeconds(uint.Parse(eit)));
           }
           else
           {
             throw new IllegalArgException("The xml file passed has an unknowk format");
           }
           break;

         case "cache-loader":
           XmlAttributeCollection loaderattrs = node.Attributes;
           string loaderlibrary = null;
           string loaderfunction = null;
           foreach(XmlAttribute tmpattr in loaderattrs)
           {
             if (tmpattr.Name == "library")
             {
               loaderlibrary = tmpattr.Value;
             }
             else if (tmpattr.Name == "function")
             {
               loaderfunction = tmpattr.Value;
             }
             else
             {
               throw new IllegalArgException("cahe-loader attributes in improper format");
             }
           }
           if (loaderlibrary != null && loaderfunction != null)
           {
             if (loaderfunction.IndexOf('.') < 0)
             {
               Type myType = typeof(FwkData);
               loaderfunction = myType.Namespace + '.' +
                 loaderlibrary + '.' + loaderfunction;
               loaderlibrary = "FwkLib";
             }
             regionAttributesFactory.SetCacheLoader(loaderlibrary, loaderfunction);
           }
           break;

         case "cache-listener":
           XmlAttributeCollection listenerattrs = node.Attributes;
           string listenerlibrary = null;
           string listenerfunction = null;
           foreach (XmlAttribute tmpattr in listenerattrs)
           {
             if (tmpattr.Name == "library")
             {
               listenerlibrary = tmpattr.Value;
             }
             else if (tmpattr.Name == "function")
             {
               listenerfunction = tmpattr.Value;
             }
             else
             {
               throw new IllegalArgException("cahe-loader attributes in improper format");
             }
           }
           if (listenerlibrary != null && listenerfunction != null)
           {
             if (listenerfunction.IndexOf('.') < 0)
             {
               Type myType = typeof(FwkData);
               listenerfunction = myType.Namespace + '.' +
                 listenerlibrary + '.' + listenerfunction;
               listenerlibrary = "FwkLib";

             }
             regionAttributesFactory.SetCacheListener(listenerlibrary, listenerfunction);
           }
           break;

         case "cache-writer":
           XmlAttributeCollection writerattrs = node.Attributes;
           string writerlibrary = null;
           string writerfunction = null;
           foreach (XmlAttribute tmpattr in writerattrs)
           {
             if (tmpattr.Name == "library")
             {
               writerlibrary = tmpattr.Value;
             }
             else if (tmpattr.Name == "function")
             {
               writerfunction = tmpattr.Value;
             }
             else
             {
               throw new IllegalArgException("cahe-loader attributes in improper format");
             }
           }
           if (writerlibrary != null && writerfunction != null)
           {
             if (writerfunction.IndexOf('.') < 0)
             {
               Type myType = typeof(FwkData);
               writerfunction = myType.Namespace + '.' +
                 writerlibrary + '.' + writerfunction;
               writerlibrary = "FwkLib";
             }
             regionAttributesFactory.SetCacheWriter(writerlibrary, writerfunction);
           }
           break;

         case "persistence-manager":
           string pmlibrary = null;
           string pmfunction = null;
           Apache.Geode.Client.Properties<string, string> prop = new Apache.Geode.Client.Properties<string, string>();
           XmlAttributeCollection pmattrs = node.Attributes;
           foreach (XmlAttribute attr in pmattrs)
           {
             if (attr.Name == "library")
             {
               pmlibrary = attr.Value;
             }
             else if (attr.Name == "function")
             {
               pmfunction = attr.Value;
             }
             else
             {
               throw new IllegalArgException("Persistence Manager attributes in wrong format: " + attr.Name);
             }
           }

           if (node.FirstChild.Name == "properties")
           {
             XmlNodeList pmpropnodes = node.FirstChild.ChildNodes;
             foreach (XmlNode propnode in pmpropnodes)
             {
               if (propnode.Name == "property")
               {
                 XmlAttributeCollection keyval = propnode.Attributes;
                 XmlAttribute keynode = keyval["name"];
                 XmlAttribute valnode = keyval["value"];

                 if (keynode.Value == "PersistenceDirectory" || keynode.Value == "EnvironmentDirectory")
                 {
                   prop.Insert(keynode.Value, valnode.Value);
                 }
                 else if (keynode.Value == "CacheSizeGb" || keynode.Value == "CacheSizeMb"
                          || keynode.Value == "PageSize" || keynode.Value == "MaxFileSize")
                 {
                   prop.Insert(keynode.Value, valnode.Value);
                 }
               }
             }
           }
           regionAttributesFactory.SetPersistenceManager(pmlibrary, pmfunction, prop);
           break;
       }
     }

     private static Apache.Geode.Client.ExpirationAction StrToExpirationAction(string str)
     {
         return (Apache.Geode.Client.ExpirationAction)Enum.Parse(typeof(Apache.Geode.Client.ExpirationAction),
         str.Replace("-", string.Empty), true);
     }
   }

   /// <summary>
   /// Reader class for <see cref="FwkData"/>
   /// </summary>
   public class FwkReadData : MarshalByRefObject
   {
     #region Private members

     private Dictionary<string, FwkData> m_dataMap =
       new Dictionary<string, FwkData>();
     private Dictionary<string, int> m_dataIndexMap =
       new Dictionary<string, int>();
     private Stack<string> m_taskNames =
       new Stack<string>();

     #endregion

     #region Private methods

     private FwkData ReadData(string key)
     {
       FwkData data;
       lock (((ICollection)m_dataMap).SyncRoot)
       {
         if (m_dataMap.ContainsKey(key))
         {
           data = m_dataMap[key];
         }
         else
         {
           try
           {
             // First search the task specific data (which overrides the global
             // data) and then search in global data for the key.
             data = Util.BBGet(TaskName, key) as FwkData;
           }
           catch (KeyNotFoundException)
           {
             data = null;
           }
           if (data == null)
           {
             try
             {
               data = Util.BBGet(string.Empty, key) as FwkData;
             }
             catch (KeyNotFoundException)
             {
               data = null;
             }
           }
           m_dataMap[key] = data;
         }
       }
       return data;
     }

     #endregion

     #region Public accessors and constants

     public const string TestRunNumKey = "TestRunNum";
     public const string HostGroupKey = "HostGroup";

     public string TaskName
     {
       get
       {
         return (m_taskNames.Count > 0 ? m_taskNames.Peek() : null);
       }
     }

     #endregion

     #region Public methods

     public void PushTaskName(string taskName)
     {
       m_taskNames.Push(taskName);
       Util.Log("FWKLIB:: Setting the taskname to [{0}]", taskName);
     }

     public void PopTaskName()
     {
       Util.Log("FWKLIB:: Removing taskname [{0}]", TaskName);
       m_taskNames.Pop();
       string oldTaskName = TaskName;
       if (oldTaskName != null)
       {
         Util.Log("FWKLIB:: Setting the taskname back to [{0}]", oldTaskName);
       }
     }

     /// <summary>
     /// Read the value of an object as a string from the server
     /// for the given key.
     /// </summary>
     /// <remarks>
     /// For the case when the key corresponds to a list, this function
     /// gives a random value if the list has 'oneOf' attribute,
     /// else gives the values from the list in sequential order.
     /// </remarks>
     /// <param name="key">The key of the string to read.</param>
     /// <returns>
     /// The string value with the given key; null if not found.
     /// </returns>
     public string GetStringValue(string key)
     {
       FwkData data = ReadData(key);
       string res = null;
       if (data != null)
       {
         if (data.Kind == DataKind.String)
         {
           lock (((ICollection)m_dataIndexMap).SyncRoot)
           {
             int currentIndex;
             if (!m_dataIndexMap.TryGetValue(key, out currentIndex))
             {
               currentIndex = 0;
             }
             if (currentIndex == 0)
             {
               res = data.Data1 as string;
               m_dataIndexMap[key] = 1;
             }
           }
         }
         else if (data.Kind == DataKind.List)
         {
           int len;
           List<string> dataList = data.Data1 as List<string>;
           if (dataList != null && (len = dataList.Count) > 0)
           {
             bool oneOf = false;
             if (data.Data2 != null && data.Data2 is bool)
             {
               oneOf = (bool)data.Data2;
             }
             if (oneOf)
             {
               res = dataList[Util.Rand(len)];
             }
             else
             {
               lock (((ICollection)m_dataIndexMap).SyncRoot)
               {
                 int currentIndex;
                 if (!m_dataIndexMap.TryGetValue(key, out currentIndex))
                 {
                   currentIndex = 0;
                 }
                 if (currentIndex < len)
                 {
                   res = dataList[currentIndex];
                   m_dataIndexMap[key] = currentIndex + 1;
                 }
               }
             }
           }
         }
         // TODO: Deal with Range here.
       }
       return res;
     }

     /// <summary>
     /// Read the value of an object as an integer from the server
     /// for the given key.
     /// </summary>
     /// <remarks>
     /// The value is assumed to be an unsigned integer.
     /// For the case when the key corresponds to a list, this function
     /// gives a random value if the list has 'oneOf' attribute,
     /// else gives the values from the list in sequential order.
     /// </remarks>
     /// <param name="key">The key of the string to read.</param>
     /// <returns>
     /// The integer value with the given key; -1 if not found.
     /// </returns>
     public int GetUIntValue(string key)
     {
       string str = GetStringValue(key);
       if (str == null)
       {
         return -1;
       }
       try
       {
         return int.Parse(str);
       }
       catch
       {
         return -1;
       }
     }

     /// <summary>
     /// Read the value of an object as time in seconds from the server
     /// for the given key.
     /// </summary>
     /// <remarks>
     /// If the value contains 'h' or 'm' then it is assumed to be in
     /// hours and minutes respectively.
     /// </remarks>
     /// <param name="key">The key of the value to read.</param>
     /// <returns>
     /// The integer value with the given key; -1 if not found.
     /// </returns>
     public int GetTimeValue(string key)
     {
       return XmlNodeReaderWriter.String2Seconds(GetStringValue(key), -1);
     }

     /// <summary>
     /// Read the value of an object as a boolean value for the given key.
     /// </summary>
     /// <remarks>
     /// If the key is not defined the default value returned is false.
     /// </remarks>
     /// <param name="key">The key of the boolean to read.</param>
     /// <returns>
     /// The boolean value with the given key;
     /// false if not found or in incorrect format.
     /// </returns>
     public bool GetBoolValue(string key)
     {
       string str = GetStringValue(key);
       if (str == null) return false;
       try
       {
         return bool.Parse(str);
       }
       catch
       {
       }
       return false;
     }

     /// <summary>
     /// Read the name of the region for the given key.
     /// </summary>
     /// <param name="key">The key of the region to read.</param>
     /// <returns>The name of the region.</returns>
     public string GetRegionName(string key)
     {
       FwkData data = ReadData(key);
       if (data != null && data.Kind == DataKind.Region)
       {
         return data.Data1 as string;
       }
       return null;
     }


     /// <summary>
     /// Reset a key to the start.
     /// </summary>
     /// <param name="key">The key to remove.</param>
     public void ResetKey(string key)
     {
       lock (((ICollection)m_dataIndexMap).SyncRoot)
       {
         if (m_dataIndexMap.ContainsKey(key))
         {
           m_dataIndexMap.Remove(key);
         }
       }
     }

     /// <summary>
     /// Clear all the keys from the local map.
     /// </summary>
     public void ClearCachedKeys()
     {
       lock (((ICollection)m_dataMap).SyncRoot)
       {
         m_dataMap.Clear();
       }
       lock (((ICollection)m_dataIndexMap).SyncRoot)
       {
         m_dataIndexMap.Clear();
       }
     }

     #endregion
   }
 }
	/*
	* 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;
	using System.Collections.Generic;
	using System.Runtime.Serialization;
	using System.Xml;


	#pragma warning disable 618

	namespace Apache.Geode.Client.FwkLib
	{
	using Apache.Geode.DUnitFramework;
	using Apache.Geode.Client.Tests;

	[Serializable]
	public enum DataKind
	{
	String,
	List,
	Region,
	Range,
	Pool
	}

	[Serializable]
	public class FwkLocalFile
	{
	private string m_name;
	private bool m_append;
	private string m_description;
	private string m_content;

	#region Public accessors

	public string Name
	{
	get
	{
	return m_name;
	}
	}

	public bool Append
	{
	get
	{
	return m_append;
	}
	}

	public string Description
	{
	get
	{
	return m_description;
	}
	}

	public string Content
	{
	get
	{
	return m_content;
	}
	}

	#endregion

	public FwkLocalFile(string name, bool append, string description, string content)
	{
	m_name = name;
	m_append = append;
	m_description = description;
	m_content = content;
	}

	public static void LoadLocalFileNodes(XmlNode node)
	{
	XmlNodeList xmlNodes = node.SelectNodes("localFile");
	if (xmlNodes != null)
	{
	foreach (XmlNode lf in xmlNodes)
	{
	XmlAttributeCollection attrcoll = lf.Attributes;
	string name = null;
	bool append = false; ;
	string description = null;
	foreach (XmlAttribute attr in attrcoll)
	{
	// Console.WriteLine("attr name " + attr.Name);
	if (attr.Name == "name")
	{
	name = attr.Name;
	}
	else if (attr.Name == "append")
	{
	if (attr.Value == "true")
	{
	append = true;
	}
	else
	{
	append = false;
	}
	}
	else if (attr.Name == "description")
	{
	description = attr.Value;
	}
	else
	{
	throw new IllegalArgException("Local file data format incorrect");
	}
	}
	FwkLocalFile lfobj = new FwkLocalFile(name, append, description, lf.InnerText);
	Util.BBSet(string.Empty, name, lfobj);
	}
	}
	}
	}

	[Serializable]
	public class FwkData
	{
	#region Private members

	private object m_data1;
	private object m_data2;
	private DataKind m_kind;

	#endregion

	#region Public accessors

	public DataKind Kind
	{
	get
	{
	return m_kind;
	}
	}

	public object Data1
	{
	get
	{
	return m_data1;
	}
	set
	{
	m_data1 = value;
	}
	}
	public object Data2
	{
	get
	{
	return m_data2;
	}
	set
	{
	m_data2 = null;
	}
	}
	#endregion

	public FwkData(object data1, object data2, DataKind kind)
	{
	m_data1 = data1;
	m_data2 = data2;
	m_kind = kind;
	}

	public static Dictionary<string, FwkData> ReadDataNodes(XmlNode node)
	{
	throw new Exception();

	}

	public static void SetThisAttribute(string name, XmlNode node, Apache.Geode.Client.RegionAttributesFactory<string, string> regionAttributesFactory)
	{
	string value = node.Value;
	switch (name)
	{
	case "caching-enabled":
	if (value == "true")
	{
	regionAttributesFactory.SetCachingEnabled(true);
	}
	else
	{
	regionAttributesFactory.SetCachingEnabled(false);
	}
	break;

	case "load-factor":
	float lf = float.Parse(value);
	regionAttributesFactory.SetLoadFactor(lf);
	break;

	case "concurrency-level":
	int cl = int.Parse(value);
	regionAttributesFactory.SetConcurrencyLevel(cl);
	break;

	case "lru-entries-limit":
	uint lel = uint.Parse(value);
	regionAttributesFactory.SetLruEntriesLimit(lel);
	break;

	case "initial-capacity":
	int ic = int.Parse(value);
	regionAttributesFactory.SetInitialCapacity(ic);
	break;

	case "disk-policy":
	if (value == "none")
	{
	regionAttributesFactory.SetDiskPolicy(Apache.Geode.Client.DiskPolicyType.None);
	}
	else if (value == "overflows")
	{
	regionAttributesFactory.SetDiskPolicy(Apache.Geode.Client.DiskPolicyType.Overflows);
	}
	else
	{
	throw new IllegalArgException("Unknown disk policy");
	}
	break;
	case "pool-name":
	if (value.Length != 0)
	{
	regionAttributesFactory.SetPoolName(value);
	}
	else
	{
	regionAttributesFactory.SetPoolName(value);
	}
	break;

	case "client-notification":
	break;

	case "region-time-to-live":
	XmlNode nlrttl = node.FirstChild;
	if (nlrttl.Name == "expiration-attributes")
	{
	XmlAttributeCollection exAttrColl = nlrttl.Attributes;
	Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
	string rttl = exAttrColl["timeout"].Value;
	regionAttributesFactory.SetRegionTimeToLive(action, TimeSpan.FromSeconds(uint.Parse(rttl)));
	}
	else
	{
	throw new IllegalArgException("The xml file passed has an unknowk format");
	}
	break;

	case "region-idle-time":
	XmlNode nlrit = node.FirstChild;
	if (nlrit.Name == "expiration-attributes")
	{
	XmlAttributeCollection exAttrColl = nlrit.Attributes;
	Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
	string rit = exAttrColl["timeout"].Value;
	regionAttributesFactory.SetRegionIdleTimeout(action, TimeSpan.FromSeconds(uint.Parse(rit)));
	}
	else
	{
	throw new IllegalArgException("The xml file passed has an unknowk format");
	}
	break;

	case "entry-time-to-live":
	XmlNode nlettl = node.FirstChild;
	if (nlettl.Name == "expiration-attributes")
	{
	XmlAttributeCollection exAttrColl = nlettl.Attributes;
	Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
	string ettl = exAttrColl["timeout"].Value;
	regionAttributesFactory.SetEntryTimeToLive(action, TimeSpan.FromSeconds(uint.Parse(ettl)));
	}
	else
	{
	throw new IllegalArgException("The xml file passed has an unknowk format");
	}
	break;

	case "entry-idle-time":
	XmlNode nleit = node.FirstChild;
	if (nleit.Name == "expiration-attributes")
	{
	XmlAttributeCollection exAttrColl = nleit.Attributes;
	Apache.Geode.Client.ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value);
	string eit = exAttrColl["timeout"].Value;
	regionAttributesFactory.SetEntryIdleTimeout(action, TimeSpan.FromSeconds(uint.Parse(eit)));
	}
	else
	{
	throw new IllegalArgException("The xml file passed has an unknowk format");
	}
	break;

	case "cache-loader":
	XmlAttributeCollection loaderattrs = node.Attributes;
	string loaderlibrary = null;
	string loaderfunction = null;
	foreach(XmlAttribute tmpattr in loaderattrs)
	{
	if (tmpattr.Name == "library")
	{
	loaderlibrary = tmpattr.Value;
	}
	else if (tmpattr.Name == "function")
	{
	loaderfunction = tmpattr.Value;
	}
	else
	{
	throw new IllegalArgException("cahe-loader attributes in improper format");
	}
	}
	if (loaderlibrary != null && loaderfunction != null)
	{
	if (loaderfunction.IndexOf('.') < 0)
	{
	Type myType = typeof(FwkData);
	loaderfunction = myType.Namespace + '.' +
	loaderlibrary + '.' + loaderfunction;
	loaderlibrary = "FwkLib";
	}
	regionAttributesFactory.SetCacheLoader(loaderlibrary, loaderfunction);
	}
	break;

	case "cache-listener":
	XmlAttributeCollection listenerattrs = node.Attributes;
	string listenerlibrary = null;
	string listenerfunction = null;
	foreach (XmlAttribute tmpattr in listenerattrs)
	{
	if (tmpattr.Name == "library")
	{
	listenerlibrary = tmpattr.Value;
	}
	else if (tmpattr.Name == "function")
	{
	listenerfunction = tmpattr.Value;
	}
	else
	{
	throw new IllegalArgException("cahe-loader attributes in improper format");
	}
	}
	if (listenerlibrary != null && listenerfunction != null)
	{
	if (listenerfunction.IndexOf('.') < 0)
	{
	Type myType = typeof(FwkData);
	listenerfunction = myType.Namespace + '.' +
	listenerlibrary + '.' + listenerfunction;
	listenerlibrary = "FwkLib";

	}
	regionAttributesFactory.SetCacheListener(listenerlibrary, listenerfunction);
	}
	break;

	case "cache-writer":
	XmlAttributeCollection writerattrs = node.Attributes;
	string writerlibrary = null;
	string writerfunction = null;
	foreach (XmlAttribute tmpattr in writerattrs)
	{
	if (tmpattr.Name == "library")
	{
	writerlibrary = tmpattr.Value;
	}
	else if (tmpattr.Name == "function")
	{
	writerfunction = tmpattr.Value;
	}
	else
	{
	throw new IllegalArgException("cahe-loader attributes in improper format");
	}
	}
	if (writerlibrary != null && writerfunction != null)
	{
	if (writerfunction.IndexOf('.') < 0)
	{
	Type myType = typeof(FwkData);
	writerfunction = myType.Namespace + '.' +
	writerlibrary + '.' + writerfunction;
	writerlibrary = "FwkLib";
	}
	regionAttributesFactory.SetCacheWriter(writerlibrary, writerfunction);
	}
	break;

	case "persistence-manager":
	string pmlibrary = null;
	string pmfunction = null;
	Apache.Geode.Client.Properties<string, string> prop = new Apache.Geode.Client.Properties<string, string>();
	XmlAttributeCollection pmattrs = node.Attributes;
	foreach (XmlAttribute attr in pmattrs)
	{
	if (attr.Name == "library")
	{
	pmlibrary = attr.Value;
	}
	else if (attr.Name == "function")
	{
	pmfunction = attr.Value;
	}
	else
	{
	throw new IllegalArgException("Persistence Manager attributes in wrong format: " + attr.Name);
	}
	}

	if (node.FirstChild.Name == "properties")
	{
	XmlNodeList pmpropnodes = node.FirstChild.ChildNodes;
	foreach (XmlNode propnode in pmpropnodes)
	{
	if (propnode.Name == "property")
	{
	XmlAttributeCollection keyval = propnode.Attributes;
	XmlAttribute keynode = keyval["name"];
	XmlAttribute valnode = keyval["value"];

	if (keynode.Value == "PersistenceDirectory" \|\| keynode.Value == "EnvironmentDirectory")
	{
	prop.Insert(keynode.Value, valnode.Value);
	}
	else if (keynode.Value == "CacheSizeGb" \|\| keynode.Value == "CacheSizeMb"
	\|\| keynode.Value == "PageSize" \|\| keynode.Value == "MaxFileSize")
	{
	prop.Insert(keynode.Value, valnode.Value);
	}
	}
	}
	}
	regionAttributesFactory.SetPersistenceManager(pmlibrary, pmfunction, prop);
	break;
	}
	}

	private static Apache.Geode.Client.ExpirationAction StrToExpirationAction(string str)
	{
	return (Apache.Geode.Client.ExpirationAction)Enum.Parse(typeof(Apache.Geode.Client.ExpirationAction),
	str.Replace("-", string.Empty), true);
	}
	}

	/// <summary>
	/// Reader class for <see cref="FwkData"/>
	/// </summary>
	public class FwkReadData : MarshalByRefObject
	{
	#region Private members

	private Dictionary<string, FwkData> m_dataMap =
	new Dictionary<string, FwkData>();
	private Dictionary<string, int> m_dataIndexMap =
	new Dictionary<string, int>();
	private Stack<string> m_taskNames =
	new Stack<string>();

	#endregion

	#region Private methods

	private FwkData ReadData(string key)
	{
	FwkData data;
	lock (((ICollection)m_dataMap).SyncRoot)
	{
	if (m_dataMap.ContainsKey(key))
	{
	data = m_dataMap[key];
	}
	else
	{
	try
	{
	// First search the task specific data (which overrides the global
	// data) and then search in global data for the key.
	data = Util.BBGet(TaskName, key) as FwkData;
	}
	catch (KeyNotFoundException)
	{
	data = null;
	}
	if (data == null)
	{
	try
	{
	data = Util.BBGet(string.Empty, key) as FwkData;
	}
	catch (KeyNotFoundException)
	{
	data = null;
	}
	}
	m_dataMap[key] = data;
	}
	}
	return data;
	}

	#endregion

	#region Public accessors and constants

	public const string TestRunNumKey = "TestRunNum";
	public const string HostGroupKey = "HostGroup";

	public string TaskName
	{
	get
	{
	return (m_taskNames.Count > 0 ? m_taskNames.Peek() : null);
	}
	}

	#endregion

	#region Public methods

	public void PushTaskName(string taskName)
	{
	m_taskNames.Push(taskName);
	Util.Log("FWKLIB:: Setting the taskname to [{0}]", taskName);
	}

	public void PopTaskName()
	{
	Util.Log("FWKLIB:: Removing taskname [{0}]", TaskName);
	m_taskNames.Pop();
	string oldTaskName = TaskName;
	if (oldTaskName != null)
	{
	Util.Log("FWKLIB:: Setting the taskname back to [{0}]", oldTaskName);
	}
	}

	/// <summary>
	/// Read the value of an object as a string from the server
	/// for the given key.
	/// </summary>
	/// <remarks>
	/// For the case when the key corresponds to a list, this function
	/// gives a random value if the list has 'oneOf' attribute,
	/// else gives the values from the list in sequential order.
	/// </remarks>
	/// <param name="key">The key of the string to read.</param>
	/// <returns>
	/// The string value with the given key; null if not found.
	/// </returns>
	public string GetStringValue(string key)
	{
	FwkData data = ReadData(key);
	string res = null;
	if (data != null)
	{
	if (data.Kind == DataKind.String)
	{
	lock (((ICollection)m_dataIndexMap).SyncRoot)
	{
	int currentIndex;
	if (!m_dataIndexMap.TryGetValue(key, out currentIndex))
	{
	currentIndex = 0;
	}
	if (currentIndex == 0)
	{
	res = data.Data1 as string;
	m_dataIndexMap[key] = 1;
	}
	}
	}
	else if (data.Kind == DataKind.List)
	{
	int len;
	List<string> dataList = data.Data1 as List<string>;
	if (dataList != null && (len = dataList.Count) > 0)
	{
	bool oneOf = false;
	if (data.Data2 != null && data.Data2 is bool)
	{
	oneOf = (bool)data.Data2;
	}
	if (oneOf)
	{
	res = dataList[Util.Rand(len)];
	}
	else
	{
	lock (((ICollection)m_dataIndexMap).SyncRoot)
	{
	int currentIndex;
	if (!m_dataIndexMap.TryGetValue(key, out currentIndex))
	{
	currentIndex = 0;
	}
	if (currentIndex < len)
	{
	res = dataList[currentIndex];
	m_dataIndexMap[key] = currentIndex + 1;
	}
	}
	}
	}
	}
	// TODO: Deal with Range here.
	}
	return res;
	}

	/// <summary>
	/// Read the value of an object as an integer from the server
	/// for the given key.
	/// </summary>
	/// <remarks>
	/// The value is assumed to be an unsigned integer.
	/// For the case when the key corresponds to a list, this function
	/// gives a random value if the list has 'oneOf' attribute,
	/// else gives the values from the list in sequential order.
	/// </remarks>
	/// <param name="key">The key of the string to read.</param>
	/// <returns>
	/// The integer value with the given key; -1 if not found.
	/// </returns>
	public int GetUIntValue(string key)
	{
	string str = GetStringValue(key);
	if (str == null)
	{
	return -1;
	}
	try
	{
	return int.Parse(str);
	}
	catch
	{
	return -1;
	}
	}

	/// <summary>
	/// Read the value of an object as time in seconds from the server
	/// for the given key.
	/// </summary>
	/// <remarks>
	/// If the value contains 'h' or 'm' then it is assumed to be in
	/// hours and minutes respectively.
	/// </remarks>
	/// <param name="key">The key of the value to read.</param>
	/// <returns>
	/// The integer value with the given key; -1 if not found.
	/// </returns>
	public int GetTimeValue(string key)
	{
	return XmlNodeReaderWriter.String2Seconds(GetStringValue(key), -1);
	}

	/// <summary>
	/// Read the value of an object as a boolean value for the given key.
	/// </summary>
	/// <remarks>
	/// If the key is not defined the default value returned is false.
	/// </remarks>
	/// <param name="key">The key of the boolean to read.</param>
	/// <returns>
	/// The boolean value with the given key;
	/// false if not found or in incorrect format.
	/// </returns>
	public bool GetBoolValue(string key)
	{
	string str = GetStringValue(key);
	if (str == null) return false;
	try
	{
	return bool.Parse(str);
	}
	catch
	{
	}
	return false;
	}

	/// <summary>
	/// Read the name of the region for the given key.
	/// </summary>
	/// <param name="key">The key of the region to read.</param>
	/// <returns>The name of the region.</returns>
	public string GetRegionName(string key)
	{
	FwkData data = ReadData(key);
	if (data != null && data.Kind == DataKind.Region)
	{
	return data.Data1 as string;
	}
	return null;
	}


	/// <summary>
	/// Reset a key to the start.
	/// </summary>
	/// <param name="key">The key to remove.</param>
	public void ResetKey(string key)
	{
	lock (((ICollection)m_dataIndexMap).SyncRoot)
	{
	if (m_dataIndexMap.ContainsKey(key))
	{
	m_dataIndexMap.Remove(key);
	}
	}
	}

	/// <summary>
	/// Clear all the keys from the local map.
	/// </summary>
	public void ClearCachedKeys()
	{
	lock (((ICollection)m_dataMap).SyncRoot)
	{
	m_dataMap.Clear();
	}
	lock (((ICollection)m_dataIndexMap).SyncRoot)
	{
	m_dataIndexMap.Clear();
	}
	}

	#endregion
	}
	}