tests/cli/NewFwkLib/FwkTask.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.Generic;
 using System.Reflection;
 using System.Text;
 using System.Xml;

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

   public class FwkTask
   {
     #region Private members

     private Delegate m_delegate;
     private Delegate m_pushTaskNameDelegate;
     private Delegate m_endDelegate;
     private List<string> m_clients;
     private TimeBomb m_timeBomb;
     private string m_class;
     private int m_timeoutMillis;
     private int m_timesToRun;
     private int m_threadCount;
     private bool m_parallel;
     private bool m_continueOnError;
     private ClientGroup m_clientGroup;
     private List<string> m_localDataNames;
     private UnitFnMethod<FwkTask, ClientBase> m_taskStartedHandler;
     private UnitFnMethod<FwkTask, ClientBase, Exception> m_taskDoneHandler;
     private bool m_taskStatus;

     #endregion

     #region Private constants and static members

     private const string PushTaskNameMethod = "PushTaskName";
     private const string EndTaskMethod = "EndTask";
     private const int DefaultTimeoutMillis = 600000;
     private static string[] ThreadCountKeys = { "threadCount", "numThreads" };
     private static Dictionary<string, int> m_GlobalTaskNames =
       new Dictionary<string, int>();
     private static Dictionary<string, Assembly> m_AssemblyMap =
       new Dictionary<string, Assembly>();
     private const string ClientCountKey = "clientCount";

     private const string NameAttrib = "name";
     private const string MethodAttrib = "action";
     private const string ClassAttrib = "class";
     private const string ContainerAttrib = "container";
     private const string WaitTimeAttrib = "waitTime";
     private const string TimesToRunAttrib = "timesToRun";
     private const string ThreadCountAttrib = "threadCount";
     private const string ParallelAttrib = "parallel";
     private const string ContinueAttrib = "continueOnError";
     private const string ArgTypes = "argTypes";

     #endregion

     #region Public accessors

     public static Dictionary<string, int> GlobalTaskNames
     {
       get
       {
         return m_GlobalTaskNames;
       }
     }

     public List<string> ClientNames
     {
       get
       {
         return m_clients;
       }
     }

     public string Name
     {
       get
       {
         return (m_timeBomb == null ? null : m_timeBomb.TaskName);
       }
     }

     public string Class
     {
       get
       {
         return m_class;
       }
     }

     public int Timeout
     {
       get
       {
         return m_timeoutMillis;
       }
     }

     public int TimesToRun
     {
       get
       {
         return m_timesToRun;
       }
     }

     public int ThreadCount
     {
       get
       {
         return m_threadCount;
       }
     }

     public bool Parallel
     {
       get
       {
         return m_parallel;
       }
     }

     public bool ContinueOnError
     {
       get
       {
         return m_continueOnError;
       }
     }

     #endregion

     #region Private methods

     private void HandleTaskStarted(ClientBase client)
     {
       if (m_taskStartedHandler != null)
       {
         m_taskStartedHandler(this, client);
       }
     }

     private void HandleTaskDone(ClientBase client, Exception ex)
     {
       if (m_taskDoneHandler != null)
       {
         m_taskStatus = (ex == null);
         m_taskDoneHandler(this, client, ex);
       }
     }

     #endregion

     #region Public methods

     public FwkTask(XmlNode node, string testName,
       UnitFnMethod<FwkTask, ClientBase> taskStartedHandler,
       UnitFnMethod<FwkTask, ClientBase, Exception> taskDoneHandler)
     {
       if (node == null)
       {
         throw new IllegalArgException("Null node for FwkTask constructor.");
       }

       #region Read the attributes

       string taskName = string.Empty;
       string containerStr = null;
       string methodName = null;
       string typeAttrib = null;
       m_timesToRun = 1;
       m_threadCount = 1;
       m_parallel = false;
       m_timeoutMillis = DefaultTimeoutMillis;
       m_continueOnError = false;
       m_class = null;

       XmlAttributeCollection xmlAttribs = node.Attributes;
       if (xmlAttribs != null)
       {
         foreach (XmlAttribute xmlAttrib in xmlAttribs)
         {
           switch (xmlAttrib.Name)
           {
             case NameAttrib:
               taskName = xmlAttrib.Value;
               break;
             case ArgTypes:
               typeAttrib = xmlAttrib.Value;
               break;
             case ContainerAttrib:
               containerStr = xmlAttrib.Value;
               break;
             case MethodAttrib:
               methodName = xmlAttrib.Value;
               break;
             case TimesToRunAttrib:
               m_timesToRun = XmlNodeReaderWriter.String2Int(xmlAttrib.Value, 1);
               break;
             case ThreadCountAttrib:
               m_threadCount = XmlNodeReaderWriter.String2Int(xmlAttrib.Value, 1);
               break;
             case ParallelAttrib:
               m_parallel = XmlNodeReaderWriter.String2Bool(xmlAttrib.Value, false);
               break;
             case WaitTimeAttrib:
               m_timeoutMillis = XmlNodeReaderWriter.String2Seconds(xmlAttrib.Value,
                 DefaultTimeoutMillis) * 1000;
               break;
             case ContinueAttrib:
               m_continueOnError = XmlNodeReaderWriter.String2Bool(xmlAttrib.Value, false);
               break;
             case ClassAttrib:
               m_class = xmlAttrib.Value;
               break;
             default:
               throw new IllegalArgException("Unknown attribute '" +
                 xmlAttrib.Name + "' found in '" + node.Name +
                 "' node.");
           }
         }
       }
       int taskNum = 1;
       if (m_GlobalTaskNames.ContainsKey(taskName))
       {
         taskNum = m_GlobalTaskNames[taskName] + 1;
       }
       m_GlobalTaskNames[taskName] = taskNum;
       taskName += '_' + taskNum.ToString();

       #endregion

       m_timeBomb = new TimeBomb();
       m_timeBomb.TaskName = testName + '.' + taskName;

       #region Create a delegate by loading the assembly

       Assembly loadAssmb = null;
       string typeName = null;
       if (containerStr != null && methodName != null)
       {
         object inst = null;
         int dotIndx;
         if ((dotIndx = containerStr.IndexOf('.')) < 0)
         {
           Type myType = this.GetType();
           loadAssmb = myType.Assembly;
           typeName = myType.Namespace + '.' + containerStr;
           Util.Log(Util.LogLevel.Info, "Assembly {0} loaded and typename is {1}", loadAssmb, typeName);
         }
         else
         {
           string assmbName = containerStr.Substring(0, dotIndx);
           if (!m_AssemblyMap.TryGetValue(assmbName, out loadAssmb))
           {
             try
             {
               loadAssmb = Assembly.Load(assmbName);
               Util.Log(Util.LogLevel.Info, "Assembly {0} loaded ", assmbName);
             }
             catch (Exception e)
             {
               throw new IllegalArgException("Cannot load assembly '" +
                 assmbName + "' for task: " + m_timeBomb.TaskName +
                 " exception: " + e);
             }
             m_AssemblyMap.Add(assmbName, loadAssmb);
           }
           typeName = containerStr.Substring(dotIndx + 1);
         }
         //string typeAttrib;
         if (loadAssmb != null)
         {
             if (typeAttrib == null)
             {
               inst = loadAssmb.CreateInstance(typeName, true);
             }
             else
             {
               //typeAttrib = "Apache.Geode.Client.Tests.ArrayOfByte,Apache.Geode.Client.Tests.ArrayOfByte";
               //typeAttrib = "System.int,System.Int32";
               string[] typeNames = typeAttrib.Split(',');
               string mangledName = typeName + "`" + typeNames.Length.ToString();

               //Type type = loadAssmb.GetType(mangledName, true, true);
               Type[] types = new Type[typeNames.Length];
              for (int index = 0; index < typeNames.Length; ++index)
               {
                 string typName = typeNames[index].Trim();
                 if (typName == "int" || typName == "Int32" || typName == "string" ||
                   typName == "String" || typName == "byte[]" || typName == "Byte[]"
                   || typName == "string[]" || typName == "String[]" || typName == "Object"
                   || typName == "object")
                 {
                   if (typName.Equals("int"))
                     typName = "Int32";
                   else if (typName.Equals("string"))
                     typName = "String";
                   else if (typName.Equals("string[]"))
                     typName = "String[]";
                   else if (typName.Equals("byte[]"))
                     typName = "Byte[]";
                   else if (typName.Equals("object"))
                     typName = "Object";
                   typName = "System." + typName;
                   //Util.Log("rjk: FwkTask: typeAttrib 33 argname {0}", typName);
                   types[index] = Type.GetType(typName.Trim());
                   //Util.Log("rjk: FwkTask: typeAttrib 34 argname {0}", typName);
                 }
                 else
                 {
                   typName = "Apache.Geode.Client.Tests." + typName;
                   types[index] = loadAssmb.GetType(typName.Trim(), true, true);
                   //Util.Log("rjk: FwkTask: typeAttrib for userobject 34 argname {0}", typName);
                 }
               }

               Type type = loadAssmb.GetType(mangledName, true, true).MakeGenericType(types);
               inst = type.GetConstructor(System.Type.EmptyTypes).Invoke(null);

             }

         }
         if (inst != null)
         {
           try
           {
             MethodInfo mInfo = inst.GetType().GetMethod(methodName,
               BindingFlags.IgnoreCase | BindingFlags.Public |
               BindingFlags.Static | BindingFlags.FlattenHierarchy |
               BindingFlags.Instance);
             m_delegate = Delegate.CreateDelegate(typeof(UnitFnMethod), inst,
               mInfo, true);
           }
           catch (Exception ex)
           {
             throw new IllegalArgException(
               "Exception while creating delegate [" + methodName + "]: " + ex);
           }
           m_pushTaskNameDelegate = Delegate.CreateDelegate(
             typeof(UnitFnMethod<string>), inst, PushTaskNameMethod, true);
           m_endDelegate = Delegate.CreateDelegate(
             typeof(UnitFnMethod), inst, EndTaskMethod, true);
         }
       }
       if (m_delegate == null)
       {
         throw new IllegalArgException("Cannot create delegate '" +
           methodName + "' for task: " + m_timeBomb.TaskName);
       }

       #endregion

       #region Add the clients

       m_clients = new List<string>();
       m_clientGroup = new ClientGroup(false);
       m_clients = FwkClient.ReadClientNames(node, false);
       List<ClientBase> clients = FwkClient.GetClients(m_clients);
       m_clientGroup.Add(clients);
       m_timeBomb.AddClients(new ClientBase[] { m_clientGroup });
       m_taskStartedHandler = taskStartedHandler;
       m_taskDoneHandler = taskDoneHandler;
       int clientCount = m_clients.Count;

       #endregion

       #region Add any data

       m_localDataNames = new List<string>();
       Dictionary<string, FwkData> data = FwkData.ReadDataNodes(node);
       // Task specific data is written as <taskname>.<key> to avoid
       // overwriting the global data, since that needs to be preserved
       // across tasks.
       if (m_threadCount > 1)
       {
         // We shall treat 'threadCount' and 'numThreads' as equivalent,
         // i.e. if 'threadCount' is defined for a task then 'numThreads'
         // shall also be written as data.
         foreach (string threadKey in ThreadCountKeys)
         {
           m_localDataNames.Add(threadKey);
           Util.BBSet(Name, threadKey,
             new FwkData(m_threadCount.ToString(), null, DataKind.String));
         }
       }
       if (clientCount > 0)
       {
         // Overwrite the clientCount (if any) with the actual value.
         Util.BBSet(Name, ClientCountKey,
         new FwkData(clientCount.ToString(), null, DataKind.String));
       }
       foreach (KeyValuePair<string, FwkData> pair in data)
       {
         m_localDataNames.Add(pair.Key);
         Util.BBSet(Name, pair.Key, pair.Value);
       }

       #endregion
     }

     public void AddClients(params ClientBase[] clients)
     {
       m_clientGroup.Add(clients);
     }

     public void SetClients(params ClientBase[] clients)
     {
       m_clientGroup.Clients.Clear();
       m_clientGroup.Add(clients);
     }

     public bool Execute()
     {
       m_taskStatus = true;
       m_timeBomb.Start(m_timeoutMillis);
       try
       {
         if (m_pushTaskNameDelegate != null)
         {
           m_clientGroup.CallFn(m_pushTaskNameDelegate,
               new object[] { m_timeBomb.TaskName });
         }
         if (m_taskStartedHandler != null || m_taskDoneHandler != null)
         {
           m_clientGroup.AddTaskHandlers(HandleTaskStarted, HandleTaskDone);
         }
         FwkReadData read = new FwkReadData();
         read.PushTaskName(Name);
         string appDomain = read.GetStringValue("appdomain");
         if (appDomain != null && appDomain.Length > 0) {
           m_clientGroup.CallFn(m_delegate, new object[] { Util.AppDomainPrefix
           + appDomain });
         }
         else {
           m_clientGroup.CallFn(m_delegate, null);
         }
         if (m_taskStartedHandler != null || m_taskDoneHandler != null)
         {
           m_clientGroup.RemoveTaskHandlers(HandleTaskStarted, HandleTaskDone);
         }
       }
       finally
       {
         m_timeBomb.Diffuse();
       }
       return m_taskStatus;
     }

     public void ClearData()
     {
       foreach (string dataName in m_localDataNames)
       {
         Util.BBRemove(Name, dataName);
       }
     }

     public void EndTask()
     {
       if (m_endDelegate != null)
       {
         m_clientGroup.CallFn(m_endDelegate, null);
       }
       m_clientGroup.RemoveObject(m_delegate.Target);
     }

     public void SetLogFile(string logPath)
     {
       m_clientGroup.SetNameLogFile(logPath);
     }

     public void SetLogLevel(Util.LogLevel logLevel)
     {
       m_clientGroup.SetLogLevel(logLevel);
     }

     public string Dump()
     {
       StringBuilder dumpStr = new StringBuilder();

       dumpStr.Append(Environment.NewLine + "The task name is: " +
         m_timeBomb.TaskName);
       dumpStr.Append(string.Format("{0}The function to be executed: " +
         "'{1}' in class '{2}'", Environment.NewLine, m_delegate.Method.Name,
         m_delegate.Method.ReflectedType.FullName));
       dumpStr.Append(Environment.NewLine + "The class of the task: " +
         m_class);
       dumpStr.Append(Environment.NewLine + "The threadCount is: " +
         m_threadCount);
       dumpStr.Append(Environment.NewLine + "Parallel attribute is: " +
         m_parallel);
       dumpStr.Append(Environment.NewLine + "Times to run is: " +
         m_timesToRun);
       dumpStr.Append(Environment.NewLine + "The clients are: ");
       foreach (string clientName in m_clients)
       {
         dumpStr.Append(Environment.NewLine + "\t" + clientName);
       }
       dumpStr.Append(Environment.NewLine + "Continue on error is: " +
         m_continueOnError);
       dumpStr.Append(Environment.NewLine + "The local data names are: ");
       foreach (string dataName in m_localDataNames)
       {
         dumpStr.Append(Environment.NewLine + '\t' + dataName);
       }
       dumpStr.Append(Environment.NewLine + "The timeout is: " +
         m_timeoutMillis);
       return dumpStr.ToString();
     }

     #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.Generic;
	using System.Reflection;
	using System.Text;
	using System.Xml;

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

	public class FwkTask
	{
	#region Private members

	private Delegate m_delegate;
	private Delegate m_pushTaskNameDelegate;
	private Delegate m_endDelegate;
	private List<string> m_clients;
	private TimeBomb m_timeBomb;
	private string m_class;
	private int m_timeoutMillis;
	private int m_timesToRun;
	private int m_threadCount;
	private bool m_parallel;
	private bool m_continueOnError;
	private ClientGroup m_clientGroup;
	private List<string> m_localDataNames;
	private UnitFnMethod<FwkTask, ClientBase> m_taskStartedHandler;
	private UnitFnMethod<FwkTask, ClientBase, Exception> m_taskDoneHandler;
	private bool m_taskStatus;

	#endregion

	#region Private constants and static members

	private const string PushTaskNameMethod = "PushTaskName";
	private const string EndTaskMethod = "EndTask";
	private const int DefaultTimeoutMillis = 600000;
	private static string[] ThreadCountKeys = { "threadCount", "numThreads" };
	private static Dictionary<string, int> m_GlobalTaskNames =
	new Dictionary<string, int>();
	private static Dictionary<string, Assembly> m_AssemblyMap =
	new Dictionary<string, Assembly>();
	private const string ClientCountKey = "clientCount";

	private const string NameAttrib = "name";
	private const string MethodAttrib = "action";
	private const string ClassAttrib = "class";
	private const string ContainerAttrib = "container";
	private const string WaitTimeAttrib = "waitTime";
	private const string TimesToRunAttrib = "timesToRun";
	private const string ThreadCountAttrib = "threadCount";
	private const string ParallelAttrib = "parallel";
	private const string ContinueAttrib = "continueOnError";
	private const string ArgTypes = "argTypes";

	#endregion

	#region Public accessors

	public static Dictionary<string, int> GlobalTaskNames
	{
	get
	{
	return m_GlobalTaskNames;
	}
	}

	public List<string> ClientNames
	{
	get
	{
	return m_clients;
	}
	}

	public string Name
	{
	get
	{
	return (m_timeBomb == null ? null : m_timeBomb.TaskName);
	}
	}

	public string Class
	{
	get
	{
	return m_class;
	}
	}

	public int Timeout
	{
	get
	{
	return m_timeoutMillis;
	}
	}

	public int TimesToRun
	{
	get
	{
	return m_timesToRun;
	}
	}

	public int ThreadCount
	{
	get
	{
	return m_threadCount;
	}
	}

	public bool Parallel
	{
	get
	{
	return m_parallel;
	}
	}

	public bool ContinueOnError
	{
	get
	{
	return m_continueOnError;
	}
	}

	#endregion

	#region Private methods

	private void HandleTaskStarted(ClientBase client)
	{
	if (m_taskStartedHandler != null)
	{
	m_taskStartedHandler(this, client);
	}
	}

	private void HandleTaskDone(ClientBase client, Exception ex)
	{
	if (m_taskDoneHandler != null)
	{
	m_taskStatus = (ex == null);
	m_taskDoneHandler(this, client, ex);
	}
	}

	#endregion

	#region Public methods

	public FwkTask(XmlNode node, string testName,
	UnitFnMethod<FwkTask, ClientBase> taskStartedHandler,
	UnitFnMethod<FwkTask, ClientBase, Exception> taskDoneHandler)
	{
	if (node == null)
	{
	throw new IllegalArgException("Null node for FwkTask constructor.");
	}

	#region Read the attributes

	string taskName = string.Empty;
	string containerStr = null;
	string methodName = null;
	string typeAttrib = null;
	m_timesToRun = 1;
	m_threadCount = 1;
	m_parallel = false;
	m_timeoutMillis = DefaultTimeoutMillis;
	m_continueOnError = false;
	m_class = null;

	XmlAttributeCollection xmlAttribs = node.Attributes;
	if (xmlAttribs != null)
	{
	foreach (XmlAttribute xmlAttrib in xmlAttribs)
	{
	switch (xmlAttrib.Name)
	{
	case NameAttrib:
	taskName = xmlAttrib.Value;
	break;
	case ArgTypes:
	typeAttrib = xmlAttrib.Value;
	break;
	case ContainerAttrib:
	containerStr = xmlAttrib.Value;
	break;
	case MethodAttrib:
	methodName = xmlAttrib.Value;
	break;
	case TimesToRunAttrib:
	m_timesToRun = XmlNodeReaderWriter.String2Int(xmlAttrib.Value, 1);
	break;
	case ThreadCountAttrib:
	m_threadCount = XmlNodeReaderWriter.String2Int(xmlAttrib.Value, 1);
	break;
	case ParallelAttrib:
	m_parallel = XmlNodeReaderWriter.String2Bool(xmlAttrib.Value, false);
	break;
	case WaitTimeAttrib:
	m_timeoutMillis = XmlNodeReaderWriter.String2Seconds(xmlAttrib.Value,
	DefaultTimeoutMillis) * 1000;
	break;
	case ContinueAttrib:
	m_continueOnError = XmlNodeReaderWriter.String2Bool(xmlAttrib.Value, false);
	break;
	case ClassAttrib:
	m_class = xmlAttrib.Value;
	break;
	default:
	throw new IllegalArgException("Unknown attribute '" +
	xmlAttrib.Name + "' found in '" + node.Name +
	"' node.");
	}
	}
	}
	int taskNum = 1;
	if (m_GlobalTaskNames.ContainsKey(taskName))
	{
	taskNum = m_GlobalTaskNames[taskName] + 1;
	}
	m_GlobalTaskNames[taskName] = taskNum;
	taskName += '_' + taskNum.ToString();

	#endregion

	m_timeBomb = new TimeBomb();
	m_timeBomb.TaskName = testName + '.' + taskName;

	#region Create a delegate by loading the assembly

	Assembly loadAssmb = null;
	string typeName = null;
	if (containerStr != null && methodName != null)
	{
	object inst = null;
	int dotIndx;
	if ((dotIndx = containerStr.IndexOf('.')) < 0)
	{
	Type myType = this.GetType();
	loadAssmb = myType.Assembly;
	typeName = myType.Namespace + '.' + containerStr;
	Util.Log(Util.LogLevel.Info, "Assembly {0} loaded and typename is {1}", loadAssmb, typeName);
	}
	else
	{
	string assmbName = containerStr.Substring(0, dotIndx);
	if (!m_AssemblyMap.TryGetValue(assmbName, out loadAssmb))
	{
	try
	{
	loadAssmb = Assembly.Load(assmbName);
	Util.Log(Util.LogLevel.Info, "Assembly {0} loaded ", assmbName);
	}
	catch (Exception e)
	{
	throw new IllegalArgException("Cannot load assembly '" +
	assmbName + "' for task: " + m_timeBomb.TaskName +
	" exception: " + e);
	}
	m_AssemblyMap.Add(assmbName, loadAssmb);
	}
	typeName = containerStr.Substring(dotIndx + 1);
	}
	//string typeAttrib;
	if (loadAssmb != null)
	{
	if (typeAttrib == null)
	{
	inst = loadAssmb.CreateInstance(typeName, true);
	}
	else
	{
	//typeAttrib = "Apache.Geode.Client.Tests.ArrayOfByte,Apache.Geode.Client.Tests.ArrayOfByte";
	//typeAttrib = "System.int,System.Int32";
	string[] typeNames = typeAttrib.Split(',');
	string mangledName = typeName + "`" + typeNames.Length.ToString();

	//Type type = loadAssmb.GetType(mangledName, true, true);
	Type[] types = new Type[typeNames.Length];
	for (int index = 0; index < typeNames.Length; ++index)
	{
	string typName = typeNames[index].Trim();
	if (typName == "int" \|\| typName == "Int32" \|\| typName == "string" \|\|
	typName == "String" \|\| typName == "byte[]" \|\| typName == "Byte[]"
	\|\| typName == "string[]" \|\| typName == "String[]" \|\| typName == "Object"
	\|\| typName == "object")
	{
	if (typName.Equals("int"))
	typName = "Int32";
	else if (typName.Equals("string"))
	typName = "String";
	else if (typName.Equals("string[]"))
	typName = "String[]";
	else if (typName.Equals("byte[]"))
	typName = "Byte[]";
	else if (typName.Equals("object"))
	typName = "Object";
	typName = "System." + typName;
	//Util.Log("rjk: FwkTask: typeAttrib 33 argname {0}", typName);
	types[index] = Type.GetType(typName.Trim());
	//Util.Log("rjk: FwkTask: typeAttrib 34 argname {0}", typName);
	}
	else
	{
	typName = "Apache.Geode.Client.Tests." + typName;
	types[index] = loadAssmb.GetType(typName.Trim(), true, true);
	//Util.Log("rjk: FwkTask: typeAttrib for userobject 34 argname {0}", typName);
	}
	}

	Type type = loadAssmb.GetType(mangledName, true, true).MakeGenericType(types);
	inst = type.GetConstructor(System.Type.EmptyTypes).Invoke(null);

	}

	}
	if (inst != null)
	{
	try
	{
	MethodInfo mInfo = inst.GetType().GetMethod(methodName,
	BindingFlags.IgnoreCase \| BindingFlags.Public \|
	BindingFlags.Static \| BindingFlags.FlattenHierarchy \|
	BindingFlags.Instance);
	m_delegate = Delegate.CreateDelegate(typeof(UnitFnMethod), inst,
	mInfo, true);
	}
	catch (Exception ex)
	{
	throw new IllegalArgException(
	"Exception while creating delegate [" + methodName + "]: " + ex);
	}
	m_pushTaskNameDelegate = Delegate.CreateDelegate(
	typeof(UnitFnMethod<string>), inst, PushTaskNameMethod, true);
	m_endDelegate = Delegate.CreateDelegate(
	typeof(UnitFnMethod), inst, EndTaskMethod, true);
	}
	}
	if (m_delegate == null)
	{
	throw new IllegalArgException("Cannot create delegate '" +
	methodName + "' for task: " + m_timeBomb.TaskName);
	}

	#endregion

	#region Add the clients

	m_clients = new List<string>();
	m_clientGroup = new ClientGroup(false);
	m_clients = FwkClient.ReadClientNames(node, false);
	List<ClientBase> clients = FwkClient.GetClients(m_clients);
	m_clientGroup.Add(clients);
	m_timeBomb.AddClients(new ClientBase[] { m_clientGroup });
	m_taskStartedHandler = taskStartedHandler;
	m_taskDoneHandler = taskDoneHandler;
	int clientCount = m_clients.Count;

	#endregion

	#region Add any data

	m_localDataNames = new List<string>();
	Dictionary<string, FwkData> data = FwkData.ReadDataNodes(node);
	// Task specific data is written as <taskname>.<key> to avoid
	// overwriting the global data, since that needs to be preserved
	// across tasks.
	if (m_threadCount > 1)
	{
	// We shall treat 'threadCount' and 'numThreads' as equivalent,
	// i.e. if 'threadCount' is defined for a task then 'numThreads'
	// shall also be written as data.
	foreach (string threadKey in ThreadCountKeys)
	{
	m_localDataNames.Add(threadKey);
	Util.BBSet(Name, threadKey,
	new FwkData(m_threadCount.ToString(), null, DataKind.String));
	}
	}
	if (clientCount > 0)
	{
	// Overwrite the clientCount (if any) with the actual value.
	Util.BBSet(Name, ClientCountKey,
	new FwkData(clientCount.ToString(), null, DataKind.String));
	}
	foreach (KeyValuePair<string, FwkData> pair in data)
	{
	m_localDataNames.Add(pair.Key);
	Util.BBSet(Name, pair.Key, pair.Value);
	}

	#endregion
	}

	public void AddClients(params ClientBase[] clients)
	{
	m_clientGroup.Add(clients);
	}

	public void SetClients(params ClientBase[] clients)
	{
	m_clientGroup.Clients.Clear();
	m_clientGroup.Add(clients);
	}

	public bool Execute()
	{
	m_taskStatus = true;
	m_timeBomb.Start(m_timeoutMillis);
	try
	{
	if (m_pushTaskNameDelegate != null)
	{
	m_clientGroup.CallFn(m_pushTaskNameDelegate,
	new object[] { m_timeBomb.TaskName });
	}
	if (m_taskStartedHandler != null \|\| m_taskDoneHandler != null)
	{
	m_clientGroup.AddTaskHandlers(HandleTaskStarted, HandleTaskDone);
	}
	FwkReadData read = new FwkReadData();
	read.PushTaskName(Name);
	string appDomain = read.GetStringValue("appdomain");
	if (appDomain != null && appDomain.Length > 0) {
	m_clientGroup.CallFn(m_delegate, new object[] { Util.AppDomainPrefix
	+ appDomain });
	}
	else {
	m_clientGroup.CallFn(m_delegate, null);
	}
	if (m_taskStartedHandler != null \|\| m_taskDoneHandler != null)
	{
	m_clientGroup.RemoveTaskHandlers(HandleTaskStarted, HandleTaskDone);
	}
	}
	finally
	{
	m_timeBomb.Diffuse();
	}
	return m_taskStatus;
	}

	public void ClearData()
	{
	foreach (string dataName in m_localDataNames)
	{
	Util.BBRemove(Name, dataName);
	}
	}

	public void EndTask()
	{
	if (m_endDelegate != null)
	{
	m_clientGroup.CallFn(m_endDelegate, null);
	}
	m_clientGroup.RemoveObject(m_delegate.Target);
	}

	public void SetLogFile(string logPath)
	{
	m_clientGroup.SetNameLogFile(logPath);
	}

	public void SetLogLevel(Util.LogLevel logLevel)
	{
	m_clientGroup.SetLogLevel(logLevel);
	}

	public string Dump()
	{
	StringBuilder dumpStr = new StringBuilder();

	dumpStr.Append(Environment.NewLine + "The task name is: " +
	m_timeBomb.TaskName);
	dumpStr.Append(string.Format("{0}The function to be executed: " +
	"'{1}' in class '{2}'", Environment.NewLine, m_delegate.Method.Name,
	m_delegate.Method.ReflectedType.FullName));
	dumpStr.Append(Environment.NewLine + "The class of the task: " +
	m_class);
	dumpStr.Append(Environment.NewLine + "The threadCount is: " +
	m_threadCount);
	dumpStr.Append(Environment.NewLine + "Parallel attribute is: " +
	m_parallel);
	dumpStr.Append(Environment.NewLine + "Times to run is: " +
	m_timesToRun);
	dumpStr.Append(Environment.NewLine + "The clients are: ");
	foreach (string clientName in m_clients)
	{
	dumpStr.Append(Environment.NewLine + "\t" + clientName);
	}
	dumpStr.Append(Environment.NewLine + "Continue on error is: " +
	m_continueOnError);
	dumpStr.Append(Environment.NewLine + "The local data names are: ");
	foreach (string dataName in m_localDataNames)
	{
	dumpStr.Append(Environment.NewLine + '\t' + dataName);
	}
	dumpStr.Append(Environment.NewLine + "The timeout is: " +
	m_timeoutMillis);
	return dumpStr.ToString();
	}

	#endregion
	}
	}