@Override public Status insert(String table, String recordKey, Map<String, ByteIterator> values) { String compositKey = createKey(table, recordKey); Map<String, String> stringValues = new HashMap<>(); StringByteIterator.putAllAsStrings(stringValues, values); try { cache().put(compositKey, stringValues); return Status.OK; } catch (Exception e) { LOGGER.error(e); return Status.ERROR; } }
@Override public MarshalledEntry<K, V> load(Object key) throws PersistenceException { byte[] bytes = this.remoteCache.get(this.marshall(key)); if (bytes == null) { return null; } Map.Entry<ByteBuffer, ByteBuffer> entry = this.unmarshallValue(bytes); return this.ctx.getMarshalledEntryFactory().newMarshalledEntry(key, entry.getKey(), entry.getValue()); }
@Override public void accept(K key) { this.remoteCache.remove(this.marshall(key)); }
@Test public void testRemoveConditional() throws IOException { assertNull(remoteCache.put("aKey", "aValue")); assertEquals(remoteCache.get("aKey"), "aValue"); assertFalse(remoteCache.remove("aKey", "aValue2")); assertTrue(remoteCache.containsKey("aKey")); assertTrue(remoteCache.remove("aKey", "aValue")); assertFalse(remoteCache.containsKey("aKey")); }
private void testEviction(String cacheName) { RemoteCache<String, String> rc = remoteCacheManager.getCache(cacheName); rc.clear(); storeKeys(rc, "A", "B", "C"); assertTrue("B".equals(rc.get("keyB"))); assertTrue("A".equals(rc.get("keyA"))); rc.put("keyD", "D"); assertEquals(3, rc.size()); assertEquals("D", rc.get("keyD")); }
@Test public void testCustomEvents() { final StaticCustomEventLogListener eventListener = new StaticCustomEventLogListener(); remoteCache.addClientListener(eventListener); try { eventListener.expectNoEvents(); remoteCache.put(1, "one"); eventListener.expectSingleCustomEvent(1, "one"); remoteCache.put(1, "newone"); eventListener.expectSingleCustomEvent(1, "newone"); remoteCache.remove(1); eventListener.expectSingleCustomEvent(1, null); } finally { remoteCache.removeClientListener(eventListener); } }
public void testHotRodPutEmbeddedGet() { final Integer key = 2; RemoteCache<Integer, String> remote = cacheFactory.getHotRodCache(); Cache<Integer, String> embedded = getEmbeddedCache(); assertEquals(null, remote.withFlags(Flag.FORCE_RETURN_VALUE).put(key, "v1")); assertEquals("v1", embedded.get(key)); assertEquals(null, remote.put(key, "v2")); assertEquals("v2", remote.withFlags(Flag.FORCE_RETURN_VALUE).put(key, "v3")); assertEquals("v3", embedded.get(key)); assertEquals("v3", remote.withFlags(Flag.FORCE_RETURN_VALUE).remove(key)); }
@Test public void testWithFlags() throws IOException { assertNull(remoteCache.put("aKey", "aValue")); assertTrue(remoteCache.containsKey("aKey")); assertEquals("aValue", remoteCache.get("aKey")); // should not return return old value assertNull(remoteCache.put("aKey", "anotherValue")); assertEquals("anotherValue", remoteCache.get("aKey")); // now should return old value assertEquals("anotherValue", remoteCache.withFlags(Flag.FORCE_RETURN_VALUE).put("aKey", "yetAnotherValue")); }
@Test public void testCustomEventsDynamic() { final DynamicCustomEventLogListener eventListener = new DynamicCustomEventLogListener(); remoteCache.addClientListener(eventListener, null, new Object[]{2}); try { eventListener.expectNoEvents(); remoteCache.put(1, "one"); eventListener.expectSingleCustomEvent(1, "one"); remoteCache.put(2, "two"); eventListener.expectSingleCustomEvent(2, null); } finally { remoteCache.removeClientListener(eventListener); } }
@Test public void testPut() throws Exception { assertNull(remoteCache.put("aKey", "aValue")); assertTrue(remoteCache.containsKey("aKey")); assertEquals(remoteCache.get("aKey"), "aValue"); }
@Test public void testEndpointConfiguration() throws Exception { RemoteCache<String, String> cache1 = rcm1.getCache("default"); RemoteCache<String, String> cache2 = rcm2.getCache("other-cache"); cache1.put("key", "value"); cache2.put("key2", "value2"); assertTrue(1 == server1.getCacheManager("default").getCache("default").getNumberOfEntries()); assertTrue(1 == server1.getCacheManager("special-cache-container").getCache("other-cache").getNumberOfEntries()); cache1.remove("key"); cache2.remove("key2"); }
public void testMixedAccess() { remoteCache.put("k1", "v1"); String rv1 = remoteCache.get("k1"); assertEquals("v1", rv1); MetadataValue<String> mv1 = remoteCache.getWithMetadata("k1"); assertEquals("v1", mv1.getValue()); String cv1 = clientCache.get("k1"); assertEquals("v1", cv1); }
@Test public void testIsEmpty() throws IOException { assertTrue(remoteCache.isEmpty()); assertNull(remoteCache.put("aKey", "aValue")); assertTrue(remoteCache.containsKey("aKey")); assertTrue(!remoteCache.isEmpty()); assertNull(remoteCache.remove("aKey")); assertTrue(!remoteCache.containsKey("aKey")); assertTrue(remoteCache.isEmpty()); }
private void doPutGet(RemoteInfinispanMBeans s, RemoteCache<Object, Object> c) { assertEquals(0, s.cache.getNumberOfEntriesInMemory()); for (int i = 0; i < 10; i++) { c.put("k" + i, "v" + i); } for (int i = 0; i < 10; i++) { assertEquals("v" + i, c.get("k" + i)); } assertEquals(10, s.cache.getNumberOfEntriesInMemory()); }
public static void testRemoveContains(RemoteCache<String, String> remoteCache) { remoteCache.put(KEY1, VALUE1); assertTrue(remoteCache.containsKey(KEY1)); remoteCache.remove(KEY1); assertFalse(remoteCache.containsKey(KEY1)); }
public static void testPutClear(RemoteCache<String, String> remoteCache) { remoteCache.put(KEY1, VALUE1); remoteCache.put(KEY2, VALUE2); remoteCache.clear(); assertFalse(remoteCache.containsKey(KEY1)); assertFalse(remoteCache.containsKey(KEY2)); assertTrue(remoteCache.isEmpty()); }
public static void testReplaceWithVersioned(RemoteCache<String, String> remoteCache) { remoteCache.clear(); remoteCache.put(KEY1, VALUE1); VersionedValue<String> v = remoteCache.getVersioned(KEY1); assertEquals(VALUE1, v.getValue()); long ver = v.getVersion(); remoteCache.replaceWithVersion(KEY1, VALUE2, ver); v = remoteCache.getVersioned(KEY1); assertEquals(VALUE2, v.getValue()); assertTrue(ver != v.getVersion()); }
@Test public void testMultipleClients() { RemoteCache<String, String> rc1 = remoteCacheManager.getCache("off-heap"); RemoteCache<String, String> rc2 = remoteCacheManager.getCache("off-heap"); rc1.clear(); for (int i = 0; i < 1000; i++) { rc1.put(String.format("key1_%d", i), String.format("value1_%d", i)); rc2.put(String.format("key2_%d", i), String.format("value2_%d", i)); } assertEquals(3, rc1.size()); assertEquals(3, rc2.size()); }