public void Can_use_batch_operations() { cache.SetAll(new Dictionary <string, string> { { "Car", "Audi" }, { "Phone", "MotoX" } }); var response = cache.GetAll <string>(new List <string> { "Car", "Phone" }); Assert.That(response["Car"], Is.EqualTo("Audi")); Assert.That(response["Phone"], Is.EqualTo("MotoX")); var singleResponse = cache.Get <string>("Phone"); Assert.That(singleResponse, Is.EqualTo("MotoX")); cache.RemoveAll(new List <string> { "Car", "Phone" }); response = cache.GetAll <string>(new List <string> { "Car", "Phone" }); Assert.That(response["Car"], Is.EqualTo(default(string))); Assert.That(response["Phone"], Is.EqualTo(default(string))); }
public void Does_SetAll_and_GetAll() { var map = 3.Times(i => new Item { Id = i, Name = "Name" + i }) .ToSafeDictionary(x => x.ToUrn()); Cache.SetAll(map); var cacheMap = Cache.GetAll <Item>(map.Keys); Assert.That(cacheMap, Is.EquivalentTo(map)); }
public ICollection <ICacheEntry <int, IBinaryObject> > GetAllBinary() { var first = Random.Next(0, Params.Instance.Value.TotalObjects - Params.Instance.Value.BatchSize); var keys = Enumerable.Range(first, Params.Instance.Value.BatchSize); return(_binaryCache.GetAll(keys)); }
/// <summary> /// Cache GetAll. /// </summary> private void GetAll(BenchmarkState state) { var idx = BenchmarkUtils.GetRandomInt(Dataset - DatasetBatchSize); var keys = Enumerable.Range(idx, DatasetBatchSize); Cache.GetAll(keys); }
public IDictionary <string, T> GetAll <T> (IEnumerable <string> keys) { CheckNotDisposedOrThrow(); if (keys == null) { throw new ArgumentNullException(nameof(keys)); } IDictionary <string, T> values = new Dictionary <string, T>(); PerKeyCacheClientRuleAggregator aggregator = new PerKeyCacheClientRuleAggregator(); try { //The naive approach would be to find the cache client for each key // then issue a Get() call for that key and value, // but that won't use any optimisation a cache client might have for bulk operations. //Issuing a GetAll() for each client with the given set of values, doesn't work either, // since that would bypass any routing. //So, we need to see first which key by which client can be resolved, // and then issue a GetAll() on each client using only the subset of keys // it can resolve aggregator.CollectAll(keys, FindRule); foreach (KeyValuePair <Guid, IList <string> > keysForClient in aggregator.KeysForCacheClient) { ICacheClient client = aggregator .CacheClients[keysForClient.Key]; IDictionary <string, T> clientValues = client.GetAll <T>(keysForClient.Value); if (clientValues != null) { foreach (KeyValuePair <string, T> valuePair in clientValues) { values.Add(valuePair); } } } } finally { aggregator.Clear(); } return(values); }
public IEnumerable <T> GetList <T>() { if (!IsCachingServer) { return(null); } try { List <Tuple <string, T> > objList = new List <Tuple <string, T> >(); var pattern = Helper.GetClassName <T>() + ":*"; IEnumerable <string> keys = Sut.SearchKeys(pattern); var data = Sut.GetAll <T>(keys); return(data.Values.AsEnumerable()); } catch (Exception ex) { LogManager.Logger.LogError(ex); return(null); } }
public static IDictionary <string, T> GetFromCache <T>(this ICacheClient cacheClient, IEnumerable <string> cacheKeys, string pattern, Func <object, T> factoryFn) { using (IRedisClient redisClient = (cacheClient as IRedisClientsManager).GetClient()){ List <string> res = redisClient.SearchKeys(pattern); if (cacheKeys != null && cacheKeys.ToList().Count > 0) { var s = (from r in res from c in cacheKeys where r == c select r).ToList(); var cache = (s != null && s.Count > 0)? cacheClient.GetAll <T>(s): new Dictionary <string, T>(); foreach (string key in cacheKeys) { if (!s.Contains(key)) { T t = factoryFn(UrnId.GetStringId(key)); if (t != null) { cacheClient.Set <T>(key, t); cache.Add(key, t); } } } return(cache); } else { return((res != null && res.Count > 0)? cacheClient.GetAll <T>(res): new Dictionary <string, T>());; } } }
public IActionResult GetAll() { ICacheClient client = getCacheClient(); var contentKeysGrab = client.SearchKeys("widget_*"); var result = client.GetAll <Widget>(contentKeysGrab).OrderBy(c => c.Key); if (result == null) { return(NotFound()); } else { return(Ok(result)); } }
public IEnumerable <KeyValuePair <string, T> > Get(IEnumerable <string> keys) { if (true) { return(keys.Select(k => new KeyValuePair <string, T>(k, client.Get <T>(keyPrefix + k))).ToArray()); } else { // https://github.com/StackExchange/StackExchange.Redis/issues/448 // this can throw an ExecutionEngineException on the StringGet portion of the method below, hence the above workaround var prefixedKeys = keys.Select(key => keyPrefix + key); var results = client.GetAll <T>(prefixedKeys); return(results.Select(kvp => new KeyValuePair <string, T>(kvp.Key.Split(':')[1], kvp.Value))); } }
protected static void AssertCacheClientMissingModelValuesAsKeysWithNullValues( ICacheClient cacheClient) { var allKeys = new[] { "test:modelkey1", "test:modelkey2", "test:modelkey3" }; var expectedValues = new[] { ModelWithIdAndName.Create(1), null, ModelWithIdAndName.Create(1) }; cacheClient.Set(allKeys[0], expectedValues[0]); cacheClient.Set(allKeys[2], expectedValues[2]); var keyValues = cacheClient.GetAll<ModelWithIdAndName>(allKeys); Assert.That(keyValues, Has.Count.EqualTo(expectedValues.Length)); for (var keyIndex = 0; keyIndex < expectedValues.Length; keyIndex++) { var key = allKeys[keyIndex]; var keyValue = keyValues[key]; ModelWithIdAndName.AssertIsEqual(keyValue, expectedValues[keyIndex]); } }
protected static void AssertCacheClientIntModelValuesAsKeysWithNullValues( ICacheClient cacheClient) { var allKeys = new[] { "test:intkey1", "test:intkey2", "test:intkey3" }; var expectedValues = new[] { 1, default(int), 3 }; cacheClient.RemoveAll(allKeys); cacheClient.Set(allKeys[0], expectedValues[0]); cacheClient.Set(allKeys[2], expectedValues[2]); var keyValues = cacheClient.GetAll<int>(allKeys); Assert.That(keyValues, Has.Count.EqualTo(expectedValues.Length)); for (var keyIndex = 0; keyIndex < expectedValues.Length; keyIndex++) { var key = allKeys[keyIndex]; var keyValue = keyValues[key]; Assert.That(keyValue, Is.EqualTo(expectedValues[keyIndex])); } }
public void CacheGet_NewNodeEnteredTopology_RequestIsRoutedToDefaultNode() { // Warm-up. Assert.AreEqual(1, _cache.Get(1)); // Before topology change. Assert.AreEqual(12, _cache.Get(12)); Assert.AreEqual(1, GetClientRequestGridIndex()); Assert.AreEqual(14, _cache.Get(14)); Assert.AreEqual(2, GetClientRequestGridIndex()); // After topology change. var cfg = GetIgniteConfiguration(); cfg.AutoGenerateIgniteInstanceName = true; using (var ignite = Ignition.Start(cfg)) { var affinityChangedTop = new AffinityTopologyVersion(ignite.GetCluster().TopologyVersion, 1); Assert.True(ignite.WaitTopology(affinityChangedTop, _cache.Name), "Failed to wait topology " + affinityChangedTop); // Warm-up. Assert.AreEqual(1, _cache.Get(1)); // Get default node index by performing non-partition-aware operation. _cache.GetAll(Enumerable.Range(1, 10)); var defaultNodeIdx = GetClientRequestGridIndex("GetAll"); Assert.Greater(defaultNodeIdx, -1); // Assert: keys 12 and 14 belong to a new node now, but we don't have the new node in the server list. // Requests are routed to default node. Assert.AreEqual(12, _cache.Get(12)); Assert.AreEqual(defaultNodeIdx, GetClientRequestGridIndex()); Assert.AreEqual(14, _cache.Get(14)); Assert.AreEqual(defaultNodeIdx, GetClientRequestGridIndex()); } }
public void CacheGet_NewNodeEnteredTopology_RequestIsRoutedToDefaultNode() { // Warm-up. Assert.AreEqual(1, _cache.Get(1)); // Before topology change. Assert.AreEqual(12, _cache.Get(12)); Assert.AreEqual(1, GetClientRequestGridIndex()); Assert.AreEqual(14, _cache.Get(14)); Assert.AreEqual(2, GetClientRequestGridIndex()); // After topology change. var cfg = GetIgniteConfiguration(); cfg.AutoGenerateIgniteInstanceName = true; using (var ignite = Ignition.Start(cfg)) { // Wait for rebalance. var events = ignite.GetEvents(); events.EnableLocal(EventType.CacheRebalanceStopped); events.WaitForLocal(EventType.CacheRebalanceStopped); // Warm-up. Assert.AreEqual(1, _cache.Get(1)); // Get default node index by performing non-partition-aware operation. _cache.GetAll(Enumerable.Range(1, 10)); var defaultNodeIdx = GetClientRequestGridIndex("GetAll"); Assert.Greater(defaultNodeIdx, -1); // Assert: keys 12 and 14 belong to a new node now, but we don't have the new node in the server list. // Requests are routed to default node. Assert.AreEqual(12, _cache.Get(12)); Assert.AreEqual(defaultNodeIdx, GetClientRequestGridIndex()); Assert.AreEqual(14, _cache.Get(14)); Assert.AreEqual(defaultNodeIdx, GetClientRequestGridIndex()); } }
protected static void AssertCacheClientMissingModelValuesAsKeysWithNullValues( ICacheClient cacheClient) { var allKeys = new[] { "test:modelkey1", "test:modelkey2", "test:modelkey3" }; var expectedValues = new[] { ModelWithIdAndName.Create(1), null, ModelWithIdAndName.Create(1) }; cacheClient.Set(allKeys[0], expectedValues[0]); cacheClient.Set(allKeys[2], expectedValues[2]); var keyValues = cacheClient.GetAll <ModelWithIdAndName>(allKeys); Assert.That(keyValues, Has.Count.EqualTo(expectedValues.Length)); for (var keyIndex = 0; keyIndex < expectedValues.Length; keyIndex++) { var key = allKeys[keyIndex]; var keyValue = keyValues[key]; ModelWithIdAndName.AssertIsEqual(keyValue, expectedValues[keyIndex]); } }
protected static void AssertCacheClientIntModelValuesAsKeysWithNullValues( ICacheClient cacheClient) { var allKeys = new[] { "test:intkey1", "test:intkey2", "test:intkey3" }; var expectedValues = new[] { 1, default(int), 3 }; cacheClient.RemoveAll(allKeys); cacheClient.Set(allKeys[0], expectedValues[0]); cacheClient.Set(allKeys[2], expectedValues[2]); var keyValues = cacheClient.GetAll <int>(allKeys); Assert.That(keyValues, Has.Count.EqualTo(expectedValues.Length)); for (var keyIndex = 0; keyIndex < expectedValues.Length; keyIndex++) { var key = allKeys[keyIndex]; var keyValue = keyValues[key]; Assert.That(keyValue, Is.EqualTo(expectedValues[keyIndex])); } }
/// <summary> /// Execute bulk Put and Get operations. /// </summary> /// <param name="ignite">Ignite instance.</param> private static void PutAllGetAll(IIgniteClient ignite) { ICacheClient <int, Organization> cache = ignite.GetCache <int, Organization>(CacheName); // Create new Organizations to store in cache. Organization org1 = new Organization( "Microsoft", new Address("1096 Eddy Street, San Francisco, CA", 94109), OrganizationType.Private, DateTime.Now ); Organization org2 = new Organization( "Red Cross", new Address("184 Fidler Drive, San Antonio, TX", 78205), OrganizationType.NonProfit, DateTime.Now ); var map = new Dictionary <int, Organization> { { 1, org1 }, { 2, org2 } }; // Put created data entries to cache. cache.PutAll(map); // Get recently created organizations as a strongly-typed fully de-serialized instances. ICollection <ICacheEntry <int, Organization> > mapFromCache = cache.GetAll(new List <int> { 1, 2 }); Console.WriteLine(); Console.WriteLine(">>> Retrieved organization instances from cache:"); foreach (ICacheEntry <int, Organization> org in mapFromCache) { Console.WriteLine(">>> " + org.Value); } }
public IDictionary <string, T> GetAll <T>(IEnumerable <object> keys) { return(_clientExt.GetAll <T>(RedisUtils.KeysBuilder <T>(keys))); }
public IDictionary <string, T> GetAll <T>(IEnumerable <string> keys) { return(cache.GetAll <T>(keys.Select(x => prefix + x))); }