| //========================================================================= |
| // 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; |
| |
| namespace GemStone.GemFire.Cache.Examples |
| { |
| using GemStone.GemFire.Cache.Tests; |
| using GemStone.GemFire.Cache; |
| |
| // Example class to perform puts/gets using one or more clients. |
| class CacheRunner |
| { |
| #region Local constants |
| |
| private static string DefaultXMLPath = "tcr_cache.xml"; |
| |
| #endregion |
| |
| #region Private static members |
| |
| private static Cache m_cache = null; |
| private static Region m_region = null; |
| |
| #endregion |
| |
| static void Main(string[] args) |
| { |
| try |
| { |
| // Connect to distributed system and cache |
| DSInit(args); |
| |
| // Enter puts and gets manually |
| DoCommand(); |
| } |
| catch (Exception ex) |
| { |
| Console.WriteLine("{0}An exception occurred: {1}", |
| Environment.NewLine, ex.Message); |
| Console.WriteLine("---[ Press <Enter> to End the Application ]---"); |
| Console.ReadLine(); |
| } |
| finally |
| { |
| try |
| { |
| // Close the cache and disconnect |
| DSClose(); |
| } |
| catch // Ignore any exception here. |
| { |
| } |
| } |
| } |
| |
| #region Local functions |
| |
| // Initialize the distributed system, setup the cache, register callbacks |
| // and user-defined classes and create the region. |
| public static void DSInit(string[] args) |
| { |
| Console.WriteLine("{0}Connecting to GemFire{0}", Environment.NewLine); |
| |
| // Register the ComplexNumber type |
| Serializable.RegisterType(ComplexNumber.Create); |
| |
| // Register the Portfolio and Position classes for Query |
| Serializable.RegisterType(Portfolio.CreateDeserializable); |
| Serializable.RegisterType(Position.CreateDeserializable); |
| |
| // Register the ExampleObject for putall and interop |
| Serializable.RegisterType(ExampleObject.CreateDeserializable); |
| |
| string xmlPath; |
| // Create a cache |
| if (args != null && args.Length > 1) |
| { |
| throw new ApplicationException(string.Format("Usage: CacheRunner " + |
| "[<XML file name>]{0}\tXML file name is optional " + |
| "and the default is {1}.", Environment.NewLine, DefaultXMLPath)); |
| } |
| else if (args != null && args.Length == 1) |
| { |
| xmlPath = args[0]; |
| } |
| else |
| { |
| xmlPath = DefaultXMLPath; |
| } |
| CacheFactory cacheFactory = CacheFactory.CreateCacheFactory(null); |
| m_cache = cacheFactory.Set("cache-xml-file", xmlPath).Create(); |
| Region[] rootRegions = m_cache.RootRegions(); |
| if (rootRegions != null && rootRegions.Length > 0) |
| { |
| SetRegion(rootRegions[rootRegions.Length - 1]); |
| } |
| else |
| { |
| throw new ApplicationException("No root regions found."); |
| } |
| } |
| |
| // Close the cache and disconnect from the distributed system. |
| public static void DSClose() |
| { |
| // Close cache |
| if (m_cache != null) |
| { |
| m_cache.Close(); |
| m_cache = null; |
| |
| Console.WriteLine("{0}Closed cache", Environment.NewLine); |
| } |
| Console.WriteLine("{0}Connection closed", Environment.NewLine); |
| } |
| |
| private static void SetRegion(Region region) |
| { |
| m_region = region; |
| RegionAttributes attrs = m_region.Attributes; |
| if (attrs.ClientNotificationEnabled) |
| { |
| m_region.RegisterAllKeys(); |
| } |
| // Add cache listener callback to region |
| if (attrs.CacheListener == null) |
| { |
| ExampleCacheListenerCallback listenerCallback = |
| new ExampleCacheListenerCallback(); |
| AttributesMutator mutator = m_region.GetAttributesMutator(); |
| mutator.SetCacheListener(listenerCallback); |
| } |
| } |
| |
| // Puts a string key and complex number value |
| public static void PutComplex(string key, ComplexNumber value) |
| { |
| m_region.Put(key, value); |
| Console.WriteLine("Put complex -- key: " + key + " value: " + value); |
| } |
| |
| // Puts a string key and string value |
| public static void PutStr(string key, string value) |
| { |
| m_region.Put(key, value); |
| Console.WriteLine("Put string -- key: " + key + " value: " + value); |
| } |
| |
| // Puts a string key and bytes value |
| public static void PutBytes(string key, string value) |
| { |
| byte[] buffer = new byte[value.Length]; |
| for (int index = 0; index < value.Length; index++) |
| { |
| buffer[index] = (byte)value[index]; |
| } |
| m_region.Put(key, buffer); |
| Console.WriteLine("Put string -- key: " + key + " value: " + value); |
| } |
| |
| // Puts a string key and object |
| public static void PutObject(string key, IGFSerializable cValue) |
| { |
| m_region.Put(key, cValue); |
| Console.WriteLine("Put -- key: " + key + " value: " + cValue); |
| } |
| |
| // Puts a string key and portfolio object |
| public static void PutPortfolio(string key, int id) |
| { |
| Portfolio portfolio = new Portfolio(id, 2); |
| m_region.Put(key, portfolio); |
| Console.WriteLine("Put portfolio -- key: " + key + " id: " + id); |
| } |
| |
| // Puts a string key and position object |
| public static void PutPosition(string key, int id) |
| { |
| Position position = new Position(key, id); |
| m_region.Put(key, position); |
| Console.WriteLine("Put position -- key: " + key + " id: " + id); |
| } |
| |
| // Gets the value, if the key exists |
| public static string GetStr(string key) |
| { |
| string testStr = string.Empty; |
| |
| IGFSerializable cValue = m_region.Get(key); |
| // Is the key found? |
| if (cValue != null) |
| { |
| testStr = cValue.ToString(); |
| |
| // Type of value? |
| if (cValue is CacheableBytes) |
| { |
| System.Text.StringBuilder sb = new System.Text.StringBuilder(); |
| CacheableBytes cBytes = cValue as CacheableBytes; |
| foreach (byte b in cBytes.Value) |
| { |
| sb.Append((char)b); |
| } |
| testStr = sb.ToString(); |
| } |
| else if (cValue is CacheableObjectXml) |
| { |
| object val = ((CacheableObjectXml)cValue).Value; |
| System.Xml.XmlDocument xd = val as System.Xml.XmlDocument; |
| if (xd != null) |
| { |
| testStr = xd.OuterXml; |
| } |
| } |
| Console.WriteLine("Get [{0}] -- key: {1}, value: {2}", |
| cValue.GetType().Name, key, testStr); |
| } |
| else |
| { |
| testStr = "NULL"; |
| Console.WriteLine("No such key in region: " + key); |
| } |
| |
| return testStr; |
| } |
| |
| // Run the given query |
| public static void RunQuery(string query, bool isRegionQuery) |
| { |
| try |
| { |
| ISelectResults results = null; |
| |
| if (isRegionQuery) |
| { |
| results = m_region.Query(query); |
| } |
| else |
| { |
| QueryService qs = m_cache.GetQueryService("examplePool"); |
| Query qry = qs.NewQuery(query); |
| results = qry.Execute(); |
| } |
| if (results is ResultSet) |
| { |
| uint index = 1; |
| foreach (IGFSerializable result in results) |
| { |
| Console.WriteLine("\tResult {0}: {1}", index, result); |
| index++; |
| } |
| } |
| else |
| { |
| StructSet ss = (StructSet)results; |
| Console.Write("Columns:"); |
| uint index = 0; |
| string colName; |
| while ((colName = ss.GetFieldName(index)) != null) |
| { |
| Console.Write('\t' + colName); |
| index++; |
| } |
| Console.WriteLine(); |
| index = 1; |
| foreach (Struct si in results) |
| { |
| Console.Write("\tResult {0}: "); |
| while (si.HasNext()) |
| { |
| Console.Write(si.Next() + " || "); |
| } |
| Console.WriteLine(); |
| index++; |
| } |
| } |
| } |
| catch (Exception ex) |
| { |
| Console.WriteLine("Exception while running the query [{0}]: {1}", |
| query, ex.Message); |
| } |
| } |
| |
| // Run the given query and display the single result value |
| public static void SelectValue(string query) |
| { |
| try |
| { |
| IGFSerializable result = m_region.SelectValue(query); |
| |
| if (result is Struct) |
| { |
| Struct si = result as Struct; |
| Console.Write("Columns:"); |
| uint index = 0; |
| string colName; |
| while ((colName = si.Set.GetFieldName(index)) != null) |
| { |
| Console.Write('\t' + colName); |
| index++; |
| } |
| Console.WriteLine(); |
| |
| index = 0; |
| Console.Write("\tResult {0}: "); |
| while (si.HasNext()) |
| { |
| Console.Write(si.Next() + " || "); |
| } |
| Console.WriteLine(); |
| index++; |
| } |
| else |
| { |
| Console.WriteLine("\tResult : {0}", result); |
| } |
| } |
| catch (Exception ex) |
| { |
| Console.WriteLine("Exception while running the query [{0}]: {1}", |
| query, ex.Message); |
| } |
| } |
| |
| private static int getTS(DateTime ts) |
| { |
| int ms = (ts.Hour * 3600 + ts.Minute * 60 + ts.Second) * 1000 + ts.Millisecond; |
| return ms; |
| } |
| |
| // Run the given query and display if value exists |
| public static void ExistsValue(string query) |
| { |
| try |
| { |
| bool result = m_region.ExistsValue(query); |
| |
| Console.WriteLine("\tResult is {0}", result); |
| } |
| catch (Exception ex) |
| { |
| Console.WriteLine("Exception while running the query [{0}]: {1}", |
| query, ex.Message); |
| } |
| } |
| |
| // Waits for input of a command (chrgn, get, put, putAll, exec, query, |
| // existsvalue, selectvalue or quit), then does just that. |
| public static void DoCommand() |
| { |
| string myCmd = string.Empty; |
| string myKey; |
| string myValue; |
| |
| while (myCmd != "quit") |
| { |
| Console.Write("{0}: chrgn, lsrgn, get, put, putAll, run, exec, query, " + |
| "existsvalue, selectvalue, quit: ", m_region.FullPath); |
| |
| string strIn = Console.ReadLine().Trim(); |
| string[] strSplit = strIn.Split(' '); |
| |
| myCmd = strSplit[0]; |
| myCmd = myCmd.ToLower(); |
| |
| if (myCmd == "q") { myCmd = "quit"; } |
| |
| switch (myCmd) |
| { |
| case "chrgn": |
| if (strSplit.Length == 2) |
| { |
| string regionPath = strSplit[1].Trim(); |
| Region region = null; |
| try |
| { |
| region = m_cache.GetRegion(regionPath); |
| } |
| catch |
| { |
| } |
| if (region == null) |
| { |
| Console.WriteLine("No region {0} found.", regionPath); |
| Console.WriteLine("usage: chrgn region-path"); |
| } |
| else |
| { |
| SetRegion(region); |
| } |
| } |
| else |
| { |
| Console.WriteLine("usage: chrgn region-path \t change the " + |
| "current region to the given region; the region-path can " + |
| "be absolute or relative to the current region"); |
| } |
| break; |
| |
| case "lsrgn": |
| Region[] rootRegions = m_cache.RootRegions(); |
| Console.Write("\nNumber of regions in Cache: {0}\n", rootRegions.Length); |
| int count = 1; |
| for (int rgnCnt = 0; rgnCnt < rootRegions.Length; rgnCnt++) |
| { |
| Console.Write("Region Name {0}: {1}\n",count++,rootRegions[rgnCnt].Name); |
| } |
| break; |
| |
| case "run": |
| if (strSplit.Length == 3) |
| { |
| string myNumber = strSplit[1]; |
| string mySize = strSplit[2]; |
| int number = int.Parse(myNumber); |
| int size = int.Parse(mySize); |
| byte[] payload = new byte[size]; |
| |
| CacheableHashMap map = new CacheableHashMap(); |
| int ts1 = getTS(System.DateTime.Now); |
| for (int i = 0; i < number; i++) |
| { |
| if (size == 0) |
| { |
| map.Add(new CacheableInt32(i), new ExampleObject(i)); |
| } |
| else |
| { |
| map.Add(CacheableInt32.Create(i), |
| CacheableBytes.Create(payload)); |
| } |
| } |
| m_region.PutAll(map); |
| int ts2 = getTS(System.DateTime.Now); |
| Double run_t = (ts2 - ts1) / 1000.0; |
| Console.WriteLine("Ops/sec: {0}, {1}, {2}", number / run_t, ts1, ts2); |
| } else { |
| Console.WriteLine("usage: run numOfKeys entrySize"); |
| } |
| break; |
| |
| case "putall": |
| if (strSplit.Length == 3) |
| { |
| myKey = strSplit[1]; |
| myValue = strSplit[2]; |
| int num = int.Parse(myValue); |
| |
| //byte[] payload = new byte[10]; |
| //for (int index = 0; index < 10; index++) |
| //{ |
| //payload[index] = 1; |
| //} |
| |
| Console.WriteLine("putAll: " + myKey + ":" + num); |
| |
| CacheableHashMap map = new CacheableHashMap(); |
| map.Clear(); |
| for (int i = 0; i < num; i++) |
| { |
| string key = myKey + i; |
| // map.Add(new CacheableString(key), (CacheableBytes)(payload)); |
| map.Add(new CacheableString(key), new ExampleObject(i)); |
| // map.Add(new CacheableString(key), new Position(i)); |
| } |
| m_region.PutAll(map); |
| } else { |
| Console.WriteLine("usage: putAll keyBase numOfKeys"); |
| } |
| break; |
| |
| case "put": |
| if (strSplit.Length == 3) |
| { |
| myKey = strSplit[1]; |
| myValue = strSplit[2]; |
| |
| // Check to see if value is ComplexNumber or String |
| ComplexNumber cNum = ComplexNumber.Parse(myValue); |
| |
| if (cNum != null) |
| { |
| // Put the key and value |
| PutComplex(myKey, cNum); |
| } |
| else |
| { |
| // Put the key and value |
| PutStr(myKey, myValue); |
| } |
| } |
| else if (strSplit.Length == 4) |
| { |
| myKey = strSplit[1]; |
| myValue = strSplit[2]; |
| string type = strSplit[3]; |
| type = type.ToLower(); |
| |
| switch (type) |
| { |
| case "str": |
| PutStr(myKey, myValue); |
| break; |
| |
| case "bytes": |
| PutBytes(myKey, myValue); |
| break; |
| |
| case "complex": |
| ComplexNumber cNum = ComplexNumber.Parse(myValue); |
| if (cNum != null) |
| { |
| PutComplex(myKey, cNum); |
| } |
| else |
| { |
| Console.WriteLine("Could not parse the complex number."); |
| } |
| break; |
| |
| case "double": |
| double dval = 0.0; |
| try |
| { |
| dval = double.Parse(myValue); |
| } |
| catch (Exception ex) |
| { |
| Console.WriteLine("Double value [{0}] not valid: {1}.", myValue, ex); |
| break; |
| } |
| PutObject(myKey, new CacheableDouble(dval)); |
| break; |
| |
| case "float": |
| float fval = 0.0F; |
| try |
| { |
| fval = float.Parse(myValue); |
| } |
| catch (Exception ex) |
| { |
| Console.WriteLine("Float value [{0}] not valid: {1}.", myValue, ex); |
| break; |
| } |
| PutObject(myKey, new CacheableFloat(fval)); |
| break; |
| |
| case "obj": |
| string xmlStr = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"; |
| xmlStr += "<IndexMessage xmlns=\"urn:example.com:FinanceManager.Messages:v1.0\">"; |
| xmlStr += "<Keys>11</Keys><Keys>22</Keys><Keys>33</Keys></IndexMessage>"; |
| |
| System.Xml.XmlDocument xd = new System.Xml.XmlDocument(); |
| xd.LoadXml(xmlStr); |
| PutObject(myKey, CacheableObjectXml.Create(xd)); |
| break; |
| |
| case "port": |
| int id = 0; |
| try |
| { |
| id = int.Parse(myValue); |
| } |
| catch |
| { |
| Console.WriteLine("Portfolio value [{0}] not a valid" |
| + " integer ID.", myValue); |
| break; |
| } |
| PutPortfolio(myKey, id); |
| break; |
| |
| case "pos": |
| int id2 = 0; |
| try |
| { |
| id2 = int.Parse(myValue); |
| } |
| catch |
| { |
| Console.WriteLine("Position value [{0}] not a valid" |
| + " integer ID.", myValue); |
| break; |
| } |
| PutPosition(myKey, id2); |
| break; |
| |
| default: |
| Console.WriteLine("usage: put key value [str|bytes|complex|double|float|obj|port|pos]"); |
| break; |
| } |
| } |
| else |
| { |
| Console.WriteLine("usage: put key value [str|bytes|complex|double|float|obj|port|pos]"); |
| } |
| break; |
| |
| case "get": |
| if (strSplit.Length == 2) |
| { |
| myKey = strSplit[1]; |
| |
| // Get the value |
| string xStr = GetStr(myKey); |
| } |
| else |
| { |
| Console.WriteLine("usage: get key"); |
| } |
| |
| break; |
| |
| case "exec": |
| if (strSplit.Length > 1) |
| { |
| string query = string.Empty; |
| for (int index = 1; index < strSplit.Length; index++) |
| { |
| query += strSplit[index] + ' '; |
| } |
| query = query.Trim(); |
| RunQuery(query, false); |
| } |
| else |
| { |
| Console.WriteLine("usage: exec <select query string>"); |
| } |
| |
| break; |
| |
| case "query": |
| if (strSplit.Length > 1) |
| { |
| string query = string.Empty; |
| for (int index = 1; index < strSplit.Length; index++) |
| { |
| query += strSplit[index] + ' '; |
| } |
| query = query.Trim(); |
| RunQuery(query, true); |
| } |
| else |
| { |
| Console.WriteLine("usage: query <query predicate>"); |
| } |
| |
| break; |
| |
| case "existsvalue": |
| if (strSplit.Length > 1) |
| { |
| string query = string.Empty; |
| for (int index = 1; index < strSplit.Length; index++) |
| { |
| query += strSplit[index] + ' '; |
| } |
| query = query.Trim(); |
| ExistsValue(query); |
| } |
| else |
| { |
| Console.WriteLine("usage: existsvalue <query predicate>"); |
| } |
| |
| break; |
| |
| case "selectvalue": |
| if (strSplit.Length > 1) |
| { |
| string query = string.Empty; |
| for (int index = 1; index < strSplit.Length; index++) |
| { |
| query += strSplit[index] + ' '; |
| } |
| query = query.Trim(); |
| SelectValue(query); |
| } |
| else |
| { |
| Console.WriteLine("usage: selectvalue <query predicate>"); |
| } |
| |
| break; |
| } |
| } |
| } |
| |
| #endregion |
| } |
| } |
