| //========================================================================= |
| // Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved. |
| // This product is protected by U.S. and international copyright |
| // and intellectual property laws. Pivotal products are covered by |
| // more patents listed at http://www.pivotal.io/patents. |
| //======================================================================== |
| |
| using System; |
| using System.Collections; |
| using System.Collections.Generic; |
| using System.Runtime.Serialization; |
| using System.Text; |
| using System.Xml; |
| |
| #pragma warning disable 618 |
| |
| namespace GemStone.GemFire.Cache.FwkLib |
| { |
| using GemStone.GemFire.DUnitFramework; |
| using GemStone.GemFire.Cache.Tests; |
| |
| /// <summary> |
| /// Exception thrown when 'Call' is invoked on a client thread/process/... |
| /// that has already exited (either due to some error/exception on the |
| /// client side or due to its 'Dispose' function being called). |
| /// </summary> |
| [Serializable] |
| public class FwkException : Exception |
| { |
| /// <summary> |
| /// Constructor to create an exception object with empty message. |
| /// </summary> |
| public FwkException() |
| : base() |
| { |
| } |
| |
| /// <summary> |
| /// Constructor to create an exception object with the given message. |
| /// </summary> |
| /// <param name="message">The exception message.</param> |
| public FwkException(string message) |
| : base(message) |
| { |
| } |
| |
| /// <summary> |
| /// Constructor to create an exception object with the given message |
| /// and with the given inner Exception. |
| /// </summary> |
| /// <param name="message">The exception message.</param> |
| /// <param name="innerException">The inner Exception object.</param> |
| public FwkException(string message, Exception innerException) |
| : base(message, innerException) |
| { |
| } |
| |
| /// <summary> |
| /// Constructor to allow deserialization of this exception by .Net remoting |
| /// </summary> |
| public FwkException(SerializationInfo info, StreamingContext context) |
| : base(info, context) |
| { |
| } |
| } |
| |
| [Serializable] |
| public struct FwkTaskData |
| { |
| #region Private members |
| |
| private string m_regionTag; |
| private string m_name; |
| private int m_numClients; |
| private int m_numKeys; |
| private int m_valueSize; |
| private int m_numThreads; |
| |
| #endregion |
| |
| #region Constructor |
| |
| public FwkTaskData(string regionTag, string name, int numClients, |
| int numKeys, int valueSize, int numThreads) |
| { |
| m_regionTag = regionTag; |
| m_name = name; |
| m_numClients = numClients; |
| m_numKeys = numKeys; |
| m_valueSize = valueSize; |
| m_numThreads = numThreads; |
| } |
| |
| #endregion |
| |
| #region Public methods and accessors |
| |
| public string RegionTag |
| { |
| get |
| { |
| return m_regionTag; |
| } |
| } |
| |
| public string Name |
| { |
| get |
| { |
| return m_name; |
| } |
| } |
| |
| public int NumClients |
| { |
| get |
| { |
| return m_numClients; |
| } |
| } |
| |
| public int NumKeys |
| { |
| get |
| { |
| return m_numKeys; |
| } |
| } |
| |
| public int ValueSize |
| { |
| get |
| { |
| return m_valueSize; |
| } |
| } |
| |
| public int NumThreads |
| { |
| get |
| { |
| return m_numThreads; |
| } |
| } |
| |
| public string GetLogString() |
| { |
| return string.Format("{0}-{1}-Clients-{2}-Keys-{3}-VSize-{4}-Threads-{5}", |
| m_regionTag, m_name, m_numClients, m_numKeys, m_valueSize, m_numThreads); |
| } |
| |
| public string GetCSVString() |
| { |
| return string.Format("{0},{1},{2},{3},{4},{5}", |
| m_regionTag, m_name, m_numClients, m_numKeys, m_valueSize, m_numThreads); |
| } |
| |
| #endregion |
| } |
| |
| public abstract class FwkTest : FwkReadData |
| { |
| #region Private members |
| |
| private static FwkTest m_currentTest = null; |
| private FwkTaskData m_taskData; |
| private List<string> m_taskRecords; |
| private const CredentialGenerator.ClassCode DefaultSecurityCode = |
| CredentialGenerator.ClassCode.LDAP; |
| |
| #endregion |
| |
| #region Public accessors and constants |
| |
| public static FwkTest CurrentTest |
| { |
| get |
| { |
| return m_currentTest; |
| } |
| } |
| |
| public const string JavaServerBB = "Cacheservers"; |
| public const string EndPointTag = "ENDPOINT:"; |
| public const string HeapLruLimitKey = "heapLruLimit"; |
| public const string RedundancyLevelKey = "redundancyLevel"; |
| public const string ConflateEventsKey = "conflateEvents"; |
| public const string SecurityParams = "securityParams"; |
| public const string SecurityScheme = "securityScheme"; |
| public const string JavaServerEPCountKey = "ServerEPCount"; |
| public const string EndPoints = "EndPoints"; |
| |
| public static Properties PER_CLIENT_FOR_MULTIUSER = null; |
| #endregion |
| |
| #region Protected members |
| |
| protected FwkTaskData TaskData |
| { |
| get |
| { |
| return m_taskData; |
| } |
| } |
| |
| #endregion |
| |
| #region Public methods |
| |
| public FwkTest() |
| : base() |
| { |
| m_currentTest = this; |
| m_taskData = new FwkTaskData(); |
| m_taskRecords = new List<string>(); |
| } |
| |
| public virtual void FwkException(string message) |
| { |
| FwkSevere(message); |
| throw new FwkException(message); |
| } |
| |
| public virtual void FwkException(string fmt, params object[] paramList) |
| { |
| FwkException(string.Format(fmt, paramList)); |
| } |
| |
| public virtual void FwkSevere(string message) |
| { |
| Util.Log(Util.LogLevel.Error, "FWKLIB:: Task[{0}] Severe: {1}", |
| TaskName, message); |
| } |
| |
| public virtual void FwkSevere(string fmt, params object[] paramList) |
| { |
| FwkSevere(string.Format(fmt, paramList)); |
| } |
| |
| public virtual void FwkWarn(string message) |
| { |
| Util.Log(Util.LogLevel.Warning, "FWKLIB:: Task[{0}]: {1}", |
| TaskName, message); |
| } |
| |
| public virtual void FwkWarn(string fmt, params object[] paramList) |
| { |
| FwkWarn(string.Format(fmt, paramList)); |
| } |
| |
| public virtual void FwkInfo(string message) |
| { |
| Util.Log(Util.LogLevel.Info, "FWKLIB:: Task[{0}]: {1}", |
| TaskName, message); |
| } |
| |
| public virtual void FwkInfo(string fmt, params object[] paramList) |
| { |
| FwkInfo(string.Format(fmt, paramList)); |
| } |
| |
| public virtual void FwkAssert(bool condition, string message) |
| { |
| if (!condition) |
| { |
| FwkException(message); |
| } |
| } |
| |
| public virtual void FwkAssert(bool condition, string fmt, |
| params object[] paramList) |
| { |
| if (!condition) |
| { |
| FwkException(fmt, paramList); |
| } |
| } |
| |
| public static void LogException(string message) |
| { |
| throw new FwkException(message); |
| } |
| |
| public static void LogException(string fmt, params object[] paramList) |
| { |
| LogException(string.Format(fmt, paramList)); |
| } |
| |
| public static void LogSevere(string message) |
| { |
| Util.Log(Util.LogLevel.Error, "FWKLIB:: Severe: {0}", message); |
| } |
| |
| public static void LogSevere(string fmt, params object[] paramList) |
| { |
| LogSevere(string.Format(fmt, paramList)); |
| } |
| |
| public static void LogWarn(string message) |
| { |
| Util.Log(Util.LogLevel.Warning, "FWKLIB:: {0}", message); |
| } |
| |
| public static void LogWarn(string fmt, params object[] paramList) |
| { |
| LogWarn(string.Format(fmt, paramList)); |
| } |
| |
| public static void LogInfo(string message) |
| { |
| Util.Log(Util.LogLevel.Info, "FWKLIB:: {0}", message); |
| } |
| |
| public static void LogInfo(string fmt, params object[] paramList) |
| { |
| LogInfo(string.Format(fmt, paramList)); |
| } |
| |
| public static void LogAssert(bool condition, string message) |
| { |
| if (!condition) |
| { |
| LogException(message); |
| } |
| } |
| |
| public static void LogAssert(bool condition, string fmt, |
| params object[] paramList) |
| { |
| if (!condition) |
| { |
| LogException(fmt, paramList); |
| } |
| } |
| |
| public virtual Region GetRootRegion() |
| { |
| string rootRegionData = GetStringValue("regionSpec"); |
| //rootRegionData = rootRegionData + "New"; |
| if (rootRegionData == null) |
| { |
| return null; |
| } |
| string rootRegionName = GetRegionName(rootRegionData); |
| try |
| { |
| return CacheHelper.GetVerifyRegion(rootRegionName); |
| } |
| catch |
| { |
| return null; |
| } |
| } |
| |
| public CredentialGenerator GetCredentialGenerator() |
| { |
| int schemeNumber; |
| try |
| { |
| schemeNumber = (int)Util.BBGet(string.Empty, |
| FwkReadData.TestRunNumKey); |
| } |
| catch (Exception) |
| { |
| schemeNumber = 1; |
| } |
| int schemeSkip = 1; |
| string securityScheme; |
| string bb = "GFE_BB"; |
| string key = "scheme"; |
| do |
| { |
| securityScheme = GetStringValue(SecurityScheme); |
| Util.BBSet(bb, key, securityScheme); |
| } |
| while (++schemeSkip <= schemeNumber); |
| CredentialGenerator.ClassCode secCode; |
| try |
| { |
| secCode = (CredentialGenerator.ClassCode)Enum.Parse(typeof( |
| CredentialGenerator.ClassCode), securityScheme, true); |
| } |
| catch (Exception) |
| { |
| FwkWarn("Skipping unknown security scheme {0}. Using default " + |
| "security scheme {1}.", securityScheme, DefaultSecurityCode); |
| secCode = DefaultSecurityCode; |
| } |
| if (secCode == CredentialGenerator.ClassCode.None) |
| { |
| return null; |
| } |
| CredentialGenerator gen = CredentialGenerator.Create(secCode, false); |
| if (gen == null) |
| { |
| FwkWarn("Skipping security scheme {0} with no generator. Using " + |
| "default security scheme.", secCode, DefaultSecurityCode); |
| secCode = DefaultSecurityCode; |
| gen = CredentialGenerator.Create(secCode, false); |
| } |
| |
| return gen; |
| } |
| |
| public void GetClientSecurityProperties(ref Properties props, |
| string regionName) |
| { |
| string securityParams = GetStringValue(SecurityParams); |
| CredentialGenerator gen;//= GetCredentialGenerator(); |
| if (securityParams == null || securityParams.Length == 0 || |
| (gen = GetCredentialGenerator()) == null) |
| { |
| FwkInfo("Security is DISABLED."); |
| return; |
| } |
| |
| FwkInfo("Security params is: " + securityParams); |
| FwkInfo("Security scheme: " + gen.GetClassCode()); |
| string dataDir = Util.GetFwkLogDir(Util.SystemType) + "/data"; |
| gen.Init(dataDir, dataDir); |
| |
| if (props == null) |
| { |
| props = new Properties(); |
| } |
| |
| Properties credentials; |
| Random rnd = new Random(); |
| if (securityParams.Equals("valid")) |
| { |
| FwkInfo("Getting valid credentials"); |
| credentials = gen.GetValidCredentials(rnd.Next()); |
| } |
| else if (securityParams.Equals("invalid")) |
| { |
| FwkInfo("Getting invalid credentials"); |
| credentials = gen.GetInvalidCredentials(rnd.Next()); |
| } |
| else |
| { |
| FwkInfo("Getting credentials for a list of operations"); |
| List<OperationCode> opCodes = new List<OperationCode>(); |
| while (securityParams != null && securityParams.Length > 0) |
| { |
| securityParams = securityParams.ToLower().Replace("_", ""); |
| OperationCode opCode; |
| if (securityParams == "create" || securityParams == "update") |
| { |
| opCode = OperationCode.Put; |
| } |
| else |
| { |
| opCode = (OperationCode)Enum.Parse(typeof( |
| OperationCode), securityParams, true); |
| } |
| opCodes.Add(opCode); |
| securityParams = GetStringValue(SecurityParams); |
| FwkInfo("Next security params: {0}", securityParams); |
| } |
| // For now only XML based authorization is supported |
| AuthzCredentialGenerator authzGen = new XmlAuthzCredentialGenerator(); |
| authzGen.Init(gen); |
| List<string> regionNameList = new List<string>(); |
| if (regionName == null || regionName.Length == 0) |
| { |
| regionName = GetStringValue("regionPaths"); |
| } |
| while (regionName != null && regionName.Length > 0) |
| { |
| regionNameList.Add(regionName); |
| regionName = GetStringValue("regionPaths"); |
| } |
| string[] regionNames = null; |
| if (regionNameList.Count > 0) |
| { |
| regionNames = regionNameList.ToArray(); |
| } |
| credentials = authzGen.GetAllowedCredentials(opCodes.ToArray(), |
| regionNames, rnd.Next()); |
| } |
| PER_CLIENT_FOR_MULTIUSER = credentials; |
| Utility.GetClientProperties(gen.AuthInit, credentials, ref props); |
| FwkInfo("Security properties entries: {0}", props); |
| } |
| private string[] GetRoundRobinEP() |
| { |
| int contactnum = GetUIntValue("contactNum"); |
| string label = "EndPoints"; |
| int epCount = (int)Util.BBGet(JavaServerBB, JavaServerEPCountKey); |
| //int epCount = (int)Util.BBGet("GFE_BB", "EP_COUNT"); |
| if (contactnum < 0) |
| contactnum = epCount; |
| string[] rbEP = new string[contactnum]; |
| string currEPKey = "CURRENTEP_COUNT"; |
| int currentEP = (int)Util.BBIncrement("GFERR_BB", currEPKey); |
| for (int i = 0; i < contactnum; i++) |
| { |
| if (currentEP > epCount) |
| { |
| Util.BBSet("GFERR_BB", currEPKey, 0); |
| currentEP = (int)Util.BBIncrement("GFERR_BB", currEPKey); |
| } |
| string key = label + "_" + currentEP.ToString(); |
| string ep = (string)Util.BBGet(JavaServerBB, key); |
| rbEP[i] = ep; |
| FwkInfo("GetRoundRobinEP = {0} key = {1} currentEP = {2}", ep, key, currentEP); |
| // rbEP[i] = ep; |
| } |
| return rbEP; |
| } |
| private void XMLParseEndPoints(string ep, bool isServer, PoolFactory pf) |
| { |
| string[] eps = ep.Split(','); |
| if (isServer) |
| { |
| bool disableShufflingEP = GetBoolValue("disableShufflingEP"); // smoke perf test |
| if (disableShufflingEP) |
| { |
| string[] rbep = GetRoundRobinEP(); |
| for (int cnt = 0; cnt < rbep.Length; cnt++) |
| { |
| FwkInfo("round robin endpoint = {0}", rbep[cnt]); |
| //string[] rep = rbep[cnt].Split(','); |
| //foreach (string endpoint in eps) |
| //{ |
| string hostName = rbep[cnt].Split(':')[0]; |
| int portNum = int.Parse(rbep[cnt].Split(':')[1]); |
| pf.AddServer(hostName, portNum); |
| //} |
| } |
| } |
| else |
| { |
| foreach (string endpoint in eps) |
| { |
| string hostName = endpoint.Split(':')[0]; |
| int portNum = int.Parse(endpoint.Split(':')[1]); |
| pf.AddServer(hostName, portNum); |
| } |
| } |
| } |
| else |
| { |
| foreach (string endpoint in eps) |
| { |
| string hostName = endpoint.Split(':')[0]; |
| int portNum = int.Parse(endpoint.Split(':')[1]); |
| pf.AddLocator(hostName, portNum); |
| } |
| } |
| } |
| |
| private void CreateCache() |
| { |
| Properties dsProps = new Properties(); |
| string rootRegionName = null; |
| GetClientSecurityProperties(ref dsProps, rootRegionName); |
| ResetKey("isDurable"); |
| bool isDC = GetBoolValue("isDurable"); |
| ResetKey("durableTimeout"); |
| int durableTimeout = 300; |
| string durableClientId = ""; |
| string conflateEvents = GetStringValue(ConflateEventsKey); |
| if (isDC) |
| { |
| durableTimeout = GetUIntValue("durableTimeout"); |
| bool isFeeder = GetBoolValue("isFeeder"); |
| if (isFeeder) |
| { |
| durableClientId = "Feeder"; |
| // VJR: Setting FeederKey because listener cannot read boolean isFeeder |
| // FeederKey is used later on by Verify task to identify feeder's key in BB |
| durableClientId = String.Format("ClientName_{0}_Count", Util.ClientNum); |
| } |
| else |
| { |
| durableClientId = String.Format("ClientName_{0}", Util.ClientNum); |
| } |
| //Util.BBSet("DURABLEBB", durableClientId,0); |
| CacheHelper.InitConfigForPoolDurable(durableClientId, durableTimeout, conflateEvents, false); |
| } |
| else |
| CacheHelper.InitConfigPool(dsProps); |
| } |
| public void CreateCacheConnect() |
| { |
| CreateCache(); |
| } |
| public virtual void CreatePool() |
| { |
| CreateCache(); |
| PoolFactory pf = PoolManager.CreateFactory(); |
| ResetKey("poolSpec"); |
| //Util.Log("rjk: CreatePool before GetStringValue"); |
| string poolRegionData = GetStringValue("poolSpec"); |
| //Util.Log("rjk: CreatePool after GetStringValue"); |
| FwkInfo("PoolSpec is :{0}", poolRegionData); |
| string poolName = null; |
| SetPoolAttributes(pf, poolRegionData, ref poolName); |
| |
| //FwkInfo("rjk CreatePool() poolname = {0}", poolName); |
| if (PoolManager.Find(poolName) == null) |
| { |
| //FwkInfo("rjk CreatePool() -1 "); |
| Pool pool = pf.Create(poolName); |
| //FwkInfo("rjk CreatePool() -2"); |
| } |
| } |
| public void SetPoolAttributes(PoolFactory pf, string spec, ref string poolName) |
| { |
| ReadXmlData(null, pf, spec, ref poolName); |
| } |
| private void SetThisPoolAttributes(PoolFactory pf,string key, string value) |
| { |
| switch (key) |
| { |
| case "free-connection-timeout": |
| int fct = int.Parse(value); |
| pf.SetFreeConnectionTimeout(fct); |
| break; |
| case "idle-timeout": |
| int it = int.Parse(value); |
| pf.SetIdleTimeout(it); |
| break; |
| case "load-conditioning-interval": |
| int lci = int.Parse(value); |
| pf.SetLoadConditioningInterval(lci); |
| break; |
| case "max-connections": |
| int mxc = int.Parse(value); |
| pf.SetMaxConnections(mxc); |
| break; |
| case "min-connections": |
| int minc = int.Parse(value); |
| pf.SetMinConnections(minc); |
| break; |
| case "ping-interval": |
| int pi = int.Parse(value); |
| pf.SetPingInterval(pi); |
| break; |
| case "read-timeout": |
| int rt = int.Parse(value); |
| pf.SetReadTimeout(rt); |
| break; |
| case "retry-attempts": |
| int ra = int.Parse(value); |
| pf.SetRetryAttempts(ra); |
| break; |
| case "server-group": |
| pf.SetServerGroup(value); |
| break; |
| case "socket-buffer-size": |
| int bs = int.Parse(value); |
| pf.SetSocketBufferSize(bs); |
| break; |
| case "subscription-ack-interval": |
| int acki = int.Parse(value); |
| pf.SetSubscriptionAckInterval(acki); |
| break; |
| case "subscription-enabled": |
| if (value == "true") |
| { |
| pf.SetSubscriptionEnabled(true); |
| } |
| else |
| { |
| pf.SetSubscriptionEnabled(false); |
| } |
| break; |
| case "subscription-message-tracking-timeout": |
| int smtt = int.Parse(value); |
| pf.SetSubscriptionMessageTrackingTimeout(smtt); |
| break; |
| case "subscription-redundancy": |
| int sr = int.Parse(value); |
| pf.SetSubscriptionRedundancy(sr); |
| break; |
| case "locators": |
| string locatorAddress = (string)Util.BBGet(string.Empty, "LOCATOR_ADDRESS_POOL"); |
| XMLParseEndPoints(locatorAddress, false, pf); |
| break; |
| case "servers": |
| string ServerEndPoints = (string)Util.BBGet("Cacheservers", "ENDPOINT:"); |
| XMLParseEndPoints(ServerEndPoints, true, pf); |
| break; |
| } |
| } |
| /* |
| public PoolFactory CreatePoolFactoryAndSetAttribute() |
| { |
| PoolFactory pf = PoolManager.CreateFactory(); |
| ResetKey("poolSpec"); |
| string poolRegionData = GetStringValue("poolSpec"); |
| //FwkInfo("PoolSpec is :{0}", poolRegionData); |
| //Properties prop = GetNewPoolAttributes(poolRegionData); |
| staing poolName = null; |
| SetPoolAttributes(pf, poolRegionData,poolName); |
| return pf; |
| }*/ |
| private void ReadXmlData(RegionFactory af, PoolFactory pf,string spec, ref string poolname) |
| { |
| const string DriverNodeName = "test-driver"; |
| string xmlFile = Util.BBGet(string.Empty, "XMLFILE") as string; |
| XmlNode node = XmlNodeReaderWriter.GetInstance(xmlFile).GetNode( |
| '/' + DriverNodeName); |
| XmlNodeList xmlNodes = node.SelectNodes("data"); |
| if (xmlNodes != null) |
| { |
| foreach (XmlNode xmlNode in xmlNodes) |
| { |
| XmlAttribute tmpattr = xmlNode.Attributes["name"]; |
| if(tmpattr.Value == spec) |
| { |
| if (xmlNode.FirstChild.Name == "snippet") |
| { |
| string regionName; |
| if (xmlNode.FirstChild.FirstChild.Name == "region") |
| { |
| //Util.Log("rjk reading region xml data attri name in fwktest"); |
| XmlAttribute nameattr = xmlNode.FirstChild.FirstChild.Attributes["name"]; |
| regionName = nameattr.Value; |
| XmlNode attrnode = xmlNode.FirstChild.FirstChild.FirstChild; |
| //AttributesFactory af = new AttributesFactory(); |
| if (attrnode.Name == "region-attributes") |
| { |
| XmlAttributeCollection attrcoll = attrnode.Attributes; |
| if (attrcoll != null) |
| { |
| foreach (XmlAttribute eachattr in attrcoll) |
| { |
| //Util.Log("rjk fwktest region attri xml data attri name = {0} , attri value = {1}", eachattr.Name, eachattr.Value); |
| SetThisAttribute(eachattr.Name, eachattr, af, ref poolname); |
| } |
| } |
| if (attrnode.ChildNodes != null) |
| { |
| foreach (XmlNode tmpnode in attrnode.ChildNodes) |
| { |
| //Util.Log("rjk fwktest region attri tmpnode xml data attri name = {0} , attri value = {1}", tmpnode.Name, tmpnode.Value); |
| SetThisAttribute(tmpnode.Name, tmpnode, af, ref poolname); |
| } |
| } |
| else |
| { |
| throw new IllegalArgException("The xml file passed has an unknown format"); |
| } |
| } |
| } |
| else if (xmlNode.FirstChild.FirstChild.Name == "pool") |
| { |
| XmlAttribute nameattr = xmlNode.FirstChild.FirstChild.Attributes["name"]; |
| poolname = nameattr.Value; |
| // Now collect the pool atributes |
| Properties prop = Properties.Create(); |
| XmlAttributeCollection attrcoll = xmlNode.FirstChild.FirstChild.Attributes; |
| if (attrcoll != null) |
| { |
| foreach (XmlAttribute eachattr in attrcoll) |
| { |
| //Util.Log("rjk fwktest xml data attri name = {0} , attri value = {1}", eachattr.Name, eachattr.Value); |
| SetThisPoolAttributes(pf, eachattr.Name, eachattr.Value); |
| } |
| } |
| else |
| { |
| throw new IllegalArgException("The xml file passed has an unknown format"); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| private static ExpirationAction StrToExpirationAction(string str) |
| { |
| return (ExpirationAction)Enum.Parse(typeof(ExpirationAction), |
| str.Replace("-", string.Empty), true); |
| } |
| public void SetRegionAttributes(RegionFactory af, string spec, ref string poolname) |
| { |
| ReadXmlData(af, null,spec, ref poolname); |
| } |
| public static void SetThisAttribute(string name, XmlNode node, RegionFactory af, ref string poolname) |
| { |
| string value = node.Value; |
| switch (name) |
| { |
| case "caching-enabled": |
| if (value == "true") |
| { |
| af.SetCachingEnabled(true); |
| } |
| else |
| { |
| af.SetCachingEnabled(false); |
| } |
| break; |
| |
| case "load-factor": |
| float lf = float.Parse(value); |
| af.SetLoadFactor(lf); |
| break; |
| |
| case "concurrency-level": |
| int cl = int.Parse(value); |
| af.SetConcurrencyLevel(cl); |
| break; |
| |
| case "lru-entries-limit": |
| uint lel = uint.Parse(value); |
| af.SetLruEntriesLimit(lel); |
| break; |
| |
| case "initial-capacity": |
| int ic = int.Parse(value); |
| af.SetInitialCapacity(ic); |
| break; |
| |
| case "disk-policy": |
| if (value == "none") |
| { |
| af.SetDiskPolicy(DiskPolicyType.None); |
| } |
| else if (value == "overflows") |
| { |
| af.SetDiskPolicy(DiskPolicyType.Overflows); |
| } |
| else |
| { |
| throw new IllegalArgException("Unknown disk policy"); |
| } |
| break; |
| case "pool-name": |
| if (value.Length != 0) |
| { |
| af.SetPoolName(value); |
| } |
| else |
| { |
| af.SetPoolName(value); |
| } |
| poolname = value; |
| break; |
| |
| case "region-time-to-live": |
| XmlNode nlrttl = node.FirstChild; |
| if (nlrttl.Name == "expiration-attributes") |
| { |
| XmlAttributeCollection exAttrColl = nlrttl.Attributes; |
| ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value); |
| string rttl = exAttrColl["timeout"].Value; |
| af.SetRegionTimeToLive(action, 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; |
| ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value); |
| string rit = exAttrColl["timeout"].Value; |
| af.SetRegionIdleTimeout(action, 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; |
| ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value); |
| string ettl = exAttrColl["timeout"].Value; |
| af.SetEntryTimeToLive(action, 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; |
| ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value); |
| string eit = exAttrColl["timeout"].Value; |
| af.SetEntryIdleTimeout(action, 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(FwkTest); |
| loaderfunction = myType.Namespace + '.' + |
| loaderlibrary + '.' + loaderfunction; |
| loaderlibrary = myType.Assembly.FullName; |
| } |
| af.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(FwkTest); |
| listenerfunction = myType.Namespace + '.' + |
| listenerlibrary + '.' + listenerfunction; |
| //Util.Log(Util.LogLevel.Info, "rjk1 cache listener in fwktest: myType.Namespace {0} " + |
| // " listenerlibrary {1} listenerfunction {2}", myType.Namespace, listenerlibrary, listenerfunction); |
| listenerlibrary = myType.Assembly.FullName; |
| //Util.Log(Util.LogLevel.Info, "rjk cache listener in fwktest inside if condition: listenerlibrary {0} listenerfunction {1}", listenerlibrary, listenerfunction); |
| } |
| Util.Log(Util.LogLevel.Info, "listenerlibrary is {0} and listenerfunction is {1}", listenerlibrary, listenerfunction); |
| af.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(FwkTest); |
| writerfunction = myType.Namespace + '.' + |
| writerlibrary + '.' + writerfunction; |
| writerlibrary = myType.Assembly.FullName; |
| } |
| af.SetCacheWriter(writerlibrary, writerfunction); |
| } |
| break; |
| |
| case "persistence-manager": |
| string pmlibrary = null; |
| string pmfunction = null; |
| Properties prop = new Properties(); |
| 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, int.Parse(valnode.Value)); |
| } |
| } |
| } |
| } |
| af.SetPersistenceManager(pmlibrary, pmfunction, prop); |
| break; |
| } |
| } |
| /* |
| private void SetRegionAttributes(Properties prop, RegionFactory rf) |
| { |
| FwkInfo("rjk SetRegionAttributes "); |
| XmlNode poolname = (prop.Find((ICacheableKey)CacheableString.Create("pool-name")) as CacheableObject).Value as XmlNode; |
| if (poolname != null) |
| { |
| rf.SetPoolName(poolname.Value); |
| } |
| XmlNode caching_enabled = (prop.Find((ICacheableKey)CacheableString.Create("caching-enabled")) as CacheableObject).Value as XmlNode; |
| if (caching_enabled != null) |
| { |
| if (caching_enabled.Value == "true") |
| { |
| rf.SetCachingEnabled(true); |
| } |
| else |
| { |
| rf.SetCachingEnabled(false); |
| } |
| } |
| |
| XmlNode load_factor = (prop.Find((ICacheableKey)CacheableString.Create("load-factor")) as CacheableObject).Value as XmlNode; |
| if (load_factor != null) |
| { |
| float lf = float.Parse(load_factor.Value); |
| rf.SetLoadFactor(lf); |
| } |
| XmlNode con_level = (prop.Find((ICacheableKey)CacheableString.Create("concurrency-level")) as CacheableObject).Value as XmlNode; |
| if (con_level != null) |
| { |
| int cl = int.Parse(con_level.Value); |
| rf.SetConcurrencyLevel(cl); |
| } |
| XmlNode lru_entry_limit = (prop.Find((ICacheableKey)CacheableString.Create("lru-entries-limit")) as CacheableObject).Value as XmlNode; |
| if (lru_entry_limit != null) |
| { |
| uint lel = uint.Parse(lru_entry_limit.Value); |
| rf.SetLruEntriesLimit(lel); |
| } |
| XmlNode initial_capacity = (prop.Find((ICacheableKey)CacheableString.Create("initial-capacity")) as CacheableObject).Value as XmlNode; |
| if (initial_capacity != null) |
| { |
| int ic = int.Parse(initial_capacity.Value); |
| rf.SetInitialCapacity(ic); |
| } |
| XmlNode disk_policy = (prop.Find((ICacheableKey)CacheableString.Create("disk-policy")) as CacheableObject).Value as XmlNode; |
| if (disk_policy.Value == "none") |
| { |
| rf.SetDiskPolicy(DiskPolicyType.None); |
| } |
| else if (disk_policy.Value == "overflows") |
| { |
| rf.SetDiskPolicy(DiskPolicyType.Overflows); |
| } |
| else |
| { |
| throw new IllegalArgException("Unknown disk policy"); |
| } |
| XmlNode region_time_to_live = (prop.Find((ICacheableKey)CacheableString.Create("region-time-to-live")) as CacheableObject).Value as XmlNode; |
| if(region_time_to_live != null) |
| { |
| XmlNode nlrttl = region_time_to_live.FirstChild; |
| if (nlrttl.Name == "expiration-attributes") |
| { |
| XmlAttributeCollection exAttrColl = nlrttl.Attributes; |
| ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value); |
| string rttl = exAttrColl["timeout"].Value; |
| rf.SetRegionTimeToLive(action, uint.Parse(rttl)); |
| } |
| else |
| { |
| throw new IllegalArgException("The xml file passed has an unknowk format"); |
| } |
| } |
| XmlNode region_idle_time = (prop.Find((ICacheableKey)CacheableString.Create("region-idle-time")) as CacheableObject).Value as XmlNode; |
| if (region_idle_time != null) |
| { |
| XmlNode nlrit = region_idle_time.FirstChild; |
| if (nlrit.Name == "expiration-attributes") |
| { |
| XmlAttributeCollection exAttrColl = nlrit.Attributes; |
| ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value); |
| string rit = exAttrColl["timeout"].Value; |
| rf.SetRegionIdleTimeout(action, uint.Parse(rit)); |
| } |
| else |
| { |
| throw new IllegalArgException("The xml file passed has an unknowk format"); |
| } |
| } |
| XmlNode entry_time_to_live = (prop.Find((ICacheableKey)CacheableString.Create("entry-time-to-live")) as CacheableObject).Value as XmlNode; |
| if (entry_time_to_live != null) |
| { |
| XmlNode nlettl = entry_time_to_live.FirstChild; |
| if (nlettl.Name == "expiration-attributes") |
| { |
| XmlAttributeCollection exAttrColl = nlettl.Attributes; |
| ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value); |
| string ettl = exAttrColl["timeout"].Value; |
| rf.SetEntryTimeToLive(action, uint.Parse(ettl)); |
| } |
| else |
| { |
| throw new IllegalArgException("The xml file passed has an unknowk format"); |
| } |
| } |
| XmlNode entry_idle_time = (prop.Find((ICacheableKey)CacheableString.Create("entry-idle-time")) as CacheableObject).Value as XmlNode; |
| if (entry_idle_time != null) |
| { |
| XmlNode nleit = entry_idle_time.FirstChild; |
| if (nleit.Name == "expiration-attributes") |
| { |
| XmlAttributeCollection exAttrColl = nleit.Attributes; |
| ExpirationAction action = StrToExpirationAction(exAttrColl["action"].Value); |
| string eit = exAttrColl["timeout"].Value; |
| rf.SetEntryIdleTimeout(action, uint.Parse(eit)); |
| } |
| else |
| { |
| throw new IllegalArgException("The xml file passed has an unknowk format"); |
| } |
| } |
| XmlNode cache_loader = (prop.Find((ICacheableKey)CacheableString.Create("cache-loader")) as CacheableObject).Value as XmlNode; |
| if(cache_loader != null){ |
| XmlAttributeCollection loaderattrs = cache_loader.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) |
| { |
| int dotIndx; |
| Type myType = typeof(FwkData); |
| if ((dotIndx = loaderlibrary.IndexOf('.')) < 0) |
| { |
| loaderfunction = myType.Namespace + '.' + |
| loaderlibrary + '.' + loaderfunction; |
| loaderlibrary = "FwkLib"; |
| } |
| else |
| { |
| loaderfunction = myType.Namespace + '.' + |
| loaderlibrary.Substring(dotIndx+1) + '.' + loaderfunction; |
| loaderlibrary = loaderlibrary.Substring(0, dotIndx); |
| |
| } |
| } |
| rf.SetCacheLoader(loaderlibrary, loaderfunction); |
| } |
| } |
| XmlNode cache_listener = (prop.Find((ICacheableKey)CacheableString.Create("cache-listener")) as CacheableObject).Value as XmlNode; |
| if(cache_listener != null) { |
| XmlAttributeCollection listenerattrs = cache_listener.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) |
| { |
| int dotIndx; |
| Type myType = typeof(FwkData); |
| if ((dotIndx = listenerlibrary.IndexOf('.')) < 0) |
| { |
| listenerfunction = myType.Namespace + '.' + |
| listenerlibrary + '.' + listenerfunction; |
| Util.Log(Util.LogLevel.Info, "rjk1 cache listener in fwkdata: myType.Namespace {0} " + |
| " listenerlibrary {1} listenerfunction {2}", myType.Namespace, listenerlibrary, listenerfunction); |
| listenerlibrary = "FwkLib"; |
| } |
| else |
| { |
| listenerfunction = myType.Namespace + '.' + |
| listenerlibrary.Substring(dotIndx+1) + '.' + listenerfunction; |
| listenerlibrary = listenerlibrary.Substring(0, dotIndx); |
| |
| } |
| } |
| Util.Log(Util.LogLevel.Info, "rjk1 cache listener in fwkdata: listenerlibrary {0} listenerfunction {1}", listenerlibrary, listenerfunction); |
| rf.SetCacheListener(listenerlibrary, listenerfunction); |
| } |
| } |
| XmlNode cache_writer = (prop.Find((ICacheableKey)CacheableString.Create("cache-writer")) as CacheableObject).Value as XmlNode; |
| if (cache_writer != null) |
| { |
| XmlAttributeCollection writerattrs = cache_writer.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) |
| { |
| int dotIndx; |
| Type myType = typeof(FwkData); |
| if ((dotIndx = writerlibrary.IndexOf('.')) < 0) |
| { |
| writerfunction = myType.Namespace + '.' + |
| writerlibrary + '.' + writerfunction; |
| writerlibrary = "FwkLib"; |
| } |
| else |
| { |
| writerfunction = myType.Namespace + '.' + |
| writerlibrary.Substring(dotIndx + 1) + '.' + writerfunction; |
| writerlibrary = writerlibrary.Substring(0, dotIndx); |
| |
| } |
| } |
| rf.SetCacheWriter(writerlibrary, writerfunction); |
| } |
| } |
| XmlNode persistence_manager = (prop.Find((ICacheableKey)CacheableString.Create("persistence-manager")) as CacheableObject).Value as XmlNode; |
| if (persistence_manager != null) |
| { |
| string pmlibrary = null; |
| string pmfunction = null; |
| Properties prop1 = new Properties(); |
| XmlAttributeCollection pmattrs = persistence_manager.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 (persistence_manager.FirstChild.Name == "properties") |
| { |
| XmlNodeList pmpropnodes = persistence_manager.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") |
| { |
| prop1.Insert(keynode.Value, valnode.Value); |
| } |
| else if (keynode.Value == "CacheSizeGb" || keynode.Value == "CacheSizeMb" |
| || keynode.Value == "PageSize" || keynode.Value == "MaxFileSize") |
| { |
| prop1.Insert(keynode.Value, int.Parse(valnode.Value)); |
| } |
| } |
| } |
| } |
| rf.SetPersistenceManager(pmlibrary, pmfunction, prop1); |
| } |
| |
| } |
| */ |
| public virtual Region CreateRootRegion() |
| { |
| return CreateRootRegion(null); |
| } |
| |
| public virtual Region CreateRootRegion(string regionName) |
| { |
| string rootRegionData = GetStringValue("regionSpec"); |
| //rootRegionData = rootRegionData + "New"; |
| return CreateRootRegion(regionName, rootRegionData); |
| } |
| |
| public virtual Region CreateRootRegion(string regionName, |
| string rootRegionData) |
| { |
| string tagName = GetStringValue("TAG"); |
| string endpoints = Util.BBGet(JavaServerBB, EndPointTag + tagName) |
| as string; |
| return CreateRootRegion(regionName, rootRegionData, endpoints); |
| } |
| |
| public virtual Region CreateRootRegion(string regionName, |
| string rootRegionData, string endpoints) |
| { |
| if (rootRegionData != null && rootRegionData.Length > 0) |
| { |
| string rootRegionName; |
| if (regionName == null || regionName.Length == 0) |
| { |
| rootRegionName = GetRegionName(rootRegionData); |
| } |
| else |
| { |
| rootRegionName = regionName; |
| } |
| if (rootRegionName != null && rootRegionName.Length > 0) |
| { |
| Region region; |
| if ((region = CacheHelper.GetRegion(rootRegionName)) == null) |
| { |
| Properties dsProps = new Properties(); |
| GetClientSecurityProperties(ref dsProps, rootRegionName); |
| |
| // Check for any setting of heap LRU limit |
| int heapLruLimit = GetUIntValue(HeapLruLimitKey); |
| if (heapLruLimit > 0) |
| { |
| dsProps.Insert("heap-lru-limit", heapLruLimit); |
| } |
| string conflateEvents = GetStringValue(ConflateEventsKey); |
| if (conflateEvents != null && conflateEvents.Length > 0) |
| { |
| dsProps.Insert("conflate-events", conflateEvents); |
| } |
| |
| ResetKey("sslEnable"); |
| bool isSslEnable = GetBoolValue("sslEnable"); |
| if (isSslEnable) |
| { |
| dsProps.Insert("ssl-enabled", "true"); |
| string keyStorePath = Util.GetFwkLogDir(Util.SystemType) + "/data/keystore"; |
| string pubkey = keyStorePath + "/client_truststore.pem"; |
| string privkey = keyStorePath + "/client_keystore.pem"; |
| dsProps.Insert("ssl-keystore", privkey); |
| dsProps.Insert("ssl-truststore", pubkey); |
| } |
| RegionFactory rootAttrs = null; |
| string m_isPool = null; |
| int redundancyLevel = 0; |
| redundancyLevel = GetUIntValue(RedundancyLevelKey); |
| string mode = Util.GetEnvironmentVariable("POOLOPT"); |
| if (endpoints != null && endpoints.Length > 0) |
| { |
| if (mode == "poolwithendpoints" || mode == "poolwithlocator" )//|| m_isPool != null) |
| { |
| FwkInfo("Setting the pool-level configurations"); |
| CacheHelper.InitConfigPool(dsProps); |
| } |
| else |
| if (redundancyLevel > 0) |
| { |
| FwkInfo("Setting the cache-level endpoints to {0}", endpoints); |
| CacheHelper.InitConfig(dsProps, endpoints, redundancyLevel); |
| } |
| |
| rootAttrs = CacheHelper.DCache.CreateRegionFactory(RegionShortcut.PROXY); |
| SetRegionAttributes(rootAttrs, rootRegionData, ref m_isPool); |
| |
| } |
| rootAttrs = CreatePool(rootAttrs, redundancyLevel); |
| region = CacheHelper.CreateRegion(rootRegionName, rootAttrs); |
| RegionAttributes regAttr = region.Attributes; |
| FwkInfo("Region attributes for {0}: {1}", rootRegionName, |
| CacheHelper.RegionAttributesToString(regAttr)); |
| } |
| Log.Info("<ExpectedException action=add>NotAuthorizedException" + |
| "</ExpectedException>"); |
| return region; |
| } |
| } |
| return null; |
| } |
| private void ParseEndPoints(string ep, bool isServer, int redundancyLevel) |
| { |
| string poolName = "_Test_Pool"; |
| PoolFactory pf = PoolManager.CreateFactory(); |
| string[] eps = ep.Split(','); |
| foreach (string endpoint in eps) |
| { |
| string hostName = endpoint.Split(':')[0]; |
| int portNum = int.Parse(endpoint.Split(':')[1]); |
| if (isServer) |
| { |
| FwkInfo("adding pool host port for server"); |
| pf.AddServer(hostName, portNum); |
| } |
| else |
| { |
| FwkInfo("adding pool host port for server"); |
| pf.AddLocator(hostName, portNum); |
| } |
| } |
| |
| pf.SetSubscriptionEnabled(true); |
| |
| ResetKey("multiUserMode"); |
| bool multiUserMode = GetBoolValue("multiUserMode"); |
| if (multiUserMode) |
| { |
| pf.SetMultiuserAuthentication(true); |
| FwkInfo("MultiUser Mode is set to true"); |
| } |
| else |
| { |
| pf.SetMultiuserAuthentication(false); |
| FwkInfo("MultiUser Mode is set to false"); |
| } |
| pf.SetFreeConnectionTimeout(180000); |
| pf.SetReadTimeout(180000); |
| pf.SetMinConnections(20); |
| pf.SetMaxConnections(30); |
| |
| if (redundancyLevel > 0) |
| pf.SetSubscriptionRedundancy(redundancyLevel); |
| if (PoolManager.Find(poolName) == null) |
| { |
| Pool pool = pf.Create(poolName); |
| } |
| FwkInfo("Create Pool complete with poolName= {0}", poolName); |
| } |
| |
| public virtual RegionFactory CreatePool(RegionFactory attr, int redundancyLevel) |
| { |
| string mode = Util.GetEnvironmentVariable("POOLOPT"); |
| if (mode == "poolwithendpoints") |
| { |
| string EndPoints = Util.BBGet(JavaServerBB, EndPointTag) as string; |
| ParseEndPoints(EndPoints, true, redundancyLevel); |
| attr = attr.SetPoolName("_Test_Pool"); |
| } |
| else if (mode == "poolwithlocator") |
| { |
| string locatorAddress = (string)Util.BBGet(string.Empty, "LOCATOR_ADDRESS_POOL"); |
| ParseEndPoints(locatorAddress, false, redundancyLevel); |
| attr = attr.SetPoolName("_Test_Pool"); |
| } |
| return attr; |
| } |
| |
| // TODO: format an appropriate line for logging. |
| public virtual void SetTaskRunInfo(string regionTag, string taskName, |
| int numKeys, int numClients, int valueSize, int numThreads) |
| { |
| m_taskData = new FwkTaskData(regionTag, taskName, numKeys, numClients, |
| valueSize, numThreads); |
| } |
| |
| public virtual void AddTaskRunRecord(int iters, TimeSpan elapsedTime) |
| { |
| double opsPerSec = iters / elapsedTime.TotalSeconds; |
| double micros = elapsedTime.TotalMilliseconds * 1000; |
| string recordStr = string.Format("{0} -- {1}ops/sec, {2} ops, {3} micros", |
| m_taskData.GetLogString(), opsPerSec, iters, micros); |
| lock (((ICollection)m_taskRecords).SyncRoot) |
| { |
| m_taskRecords.Add(recordStr); |
| } |
| Util.RawLog(string.Format("[PerfSuite] {0}{1}", recordStr, |
| Environment.NewLine)); |
| Util.RawLog(string.Format("[PerfData],{0},{1},{2},{3},{4}{5}", |
| m_taskData.GetCSVString(), opsPerSec, iters, micros, |
| DateTime.Now.ToString("G"), Environment.NewLine)); |
| } |
| |
| public virtual void RunTask(ClientTask task, int numThreads, |
| int iters, int timedInterval, int maxTime, object data) |
| { |
| ClientBase client = null; |
| try |
| { |
| if (numThreads > 1) |
| { |
| client = ClientGroup.Create(UnitThread.Create, numThreads); |
| } |
| else |
| { |
| client = new UnitThread(); |
| } |
| UnitFnMethod<UnitFnMethod<int, object>, int, object> taskDeleg = |
| new UnitFnMethod<UnitFnMethod<int, object>, int, object>( |
| client.Call<int, object>); |
| task.StartRun(); |
| IAsyncResult taskRes = taskDeleg.BeginInvoke( |
| task.DoTask, iters, data, null, null); |
| if (timedInterval > 0) |
| { |
| System.Threading.Thread.Sleep(timedInterval); |
| task.EndRun(); |
| } |
| if (maxTime <= 0) |
| { |
| taskRes.AsyncWaitHandle.WaitOne(); |
| } |
| else if (!taskRes.AsyncWaitHandle.WaitOne(maxTime, false)) |
| { |
| throw new ClientTimeoutException("RunTask() timed out."); |
| } |
| taskDeleg.EndInvoke(taskRes); |
| task.EndRun(); |
| } |
| finally |
| { |
| if (client != null) |
| { |
| client.Dispose(); |
| } |
| } |
| } |
| |
| public virtual void EndTask() |
| { |
| lock (((ICollection)m_taskRecords).SyncRoot) |
| { |
| if (m_taskRecords.Count > 0) |
| { |
| StringBuilder summarySB = new StringBuilder(); |
| foreach (string taskRecord in m_taskRecords) |
| { |
| summarySB.Append(Environment.NewLine + '\t' + taskRecord); |
| } |
| FwkInfo("TIMINGS:: Summary: {0}", summarySB.ToString()); |
| m_taskRecords.Clear(); |
| } |
| } |
| ClearCachedKeys(); |
| PopTaskName(); |
| } |
| |
| public QueryService CheckQueryService() |
| { |
| string mode = Util.GetEnvironmentVariable("POOLOPT"); |
| if (mode == "poolwithendpoints" || mode == "poolwithlocator") |
| { |
| Pool pool = PoolManager.Find("_Test_Pool"); |
| return pool.GetQueryService(); |
| } |
| else |
| { |
| return CacheHelper.DCache.GetQueryService(); |
| } |
| |
| } |
| |
| #endregion |
| } |
| } |
