@Override public VersionedValue<V> getVersioned(K key) { return delegate.getVersioned(key); }
private void getRemoteVersion() { VersionedValue<Long> versioned = remoteCache.getVersioned( id ); if ( versioned == null ) { throw log.criticalDataLossDetected(); } lastKnownVersion = versioned.getVersion(); lastKnownRemoteValue = (Long) versioned.getValue(); }
public static void testGetVersioned(RemoteCache<String, String> remoteCache) { assertNull(remoteCache.getVersioned(NON_EXISTENT_KEY)); }
public static void testRemoveWithVersionAsync(RemoteCache<String, String> remoteCache) throws Exception { remoteCache.clear(); remoteCache.put(KEY1, VALUE1); VersionedValue<String> v = remoteCache.getVersioned(KEY1); assertEquals(VALUE1, v.getValue()); long ver = v.getVersion(); CompletableFuture<Boolean> f = remoteCache.removeWithVersionAsync(KEY1, ver); f.get(ASYNC_TIMEOUT, TimeUnit.SECONDS); v = remoteCache.getVersioned(KEY1); if (v != null) assertTrue(ver != v.getVersion()); }
public static void testRemoveWithVersion(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.removeWithVersion(KEY1, ver); v = remoteCache.getVersioned(KEY1); if (v != null) assertTrue(ver != v.getVersion()); }
public static void testReplaceWithVersionAsync(RemoteCache<String, String> remoteCache) throws Exception { remoteCache.clear(); remoteCache.put(KEY1, VALUE1); VersionedValue<String> v = remoteCache.getVersioned(KEY1); assertEquals(VALUE1, v.getValue()); long ver = v.getVersion(); CompletableFuture<Boolean> f = remoteCache.replaceWithVersionAsync(KEY1, VALUE2, ver); f.get(ASYNC_TIMEOUT, TimeUnit.SECONDS); v = remoteCache.getVersioned(KEY1); assertEquals(VALUE2, v.getValue()); assertTrue(ver != v.getVersion()); }
@Test public void testReplaceWithVersionWithLifespan() throws Exception { int lifespanInSecs = 1; assertNull(remoteCache.replace("aKey", "aValue")); remoteCache.put("aKey", "aValue"); VersionedValue valueBinary = remoteCache.getVersioned("aKey"); assertTrue(remoteCache.replaceWithVersion("aKey", "aNewValue", valueBinary.getVersion(), lifespanInSecs)); // version should have changed; value should have changed VersionedValue entry2 = remoteCache.getVersioned("aKey"); assertNotEquals(entry2.getVersion(), valueBinary.getVersion()); assertEquals("aNewValue", entry2.getValue()); sleepForSecs(lifespanInSecs + 1); assertNull(remoteCache.getVersioned("aKey")); }
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()); }
public void testHotRodReplace() throws Exception { final String key = "5"; final byte[] value1 = "v1".getBytes(); final byte[] value2 = "v2".getBytes(); // 1. Put with HotRod RemoteCache<Object, Object> remote = cacheFactory1.getHotRodCache(); assertNull(remote.withFlags(Flag.FORCE_RETURN_VALUE).put(key, value1)); // 2. Replace with HotRod VersionedValue versioned = cacheFactory1.getHotRodCache().getVersioned(key); assertTrue(cacheFactory1.getHotRodCache().replaceWithVersion(key, value2, versioned.getVersion())); }
public static void testPutGetVersioned(RemoteCache<String, String> remoteCache) { remoteCache.clear(); remoteCache.put(KEY1, VALUE1); VersionedValue<String> v = remoteCache.getVersioned(KEY1); assertEquals(VALUE1, v.getValue()); assertTrue(v.getVersion() != 0); }
@Test public void testReplaceWithVersionAsync() throws Exception { assertNull(remoteCache.replace("aKey", "aValue")); remoteCache.put("aKey", "aValue"); VersionedValue valueBinary = remoteCache.getVersioned("aKey"); // replacement should take place (and so return true) CompletableFuture<Boolean> future = remoteCache.replaceWithVersionAsync("aKey", "aNewValue", valueBinary.getVersion()); assertTrue(future.get()); // version should have changed; value should have changed VersionedValue entry2 = remoteCache.getVersioned("aKey"); assertNotEquals(entry2.getVersion(), valueBinary.getVersion()); assertEquals("aNewValue", entry2.getValue()); // replacement should not take place because we have changed the value future = remoteCache.replaceWithVersionAsync("aKey", "aNewValue", valueBinary.getVersion()); assertFalse(future.get()); }
public void testHotRodReplace() throws Exception { final byte[] key = "5".getBytes(); final String value1 = "v1"; final String value2 = "v2"; // 1. Put with HotRod RemoteCache<Object, Object> remote = cacheFactory1.getHotRodCache(); assertNull(remote.withFlags(Flag.FORCE_RETURN_VALUE).put(key, value1)); // 2. Replace with HotRod VersionedValue versioned = cacheFactory1.getHotRodCache().getVersioned(key); assertTrue(cacheFactory1.getHotRodCache().replaceWithVersion(key, value2, versioned.getVersion())); }
public void testHotRodRemove() throws Exception { final String key = "7"; final byte[] value = "v1".getBytes(); // 1. Put with HotRod RemoteCache<Object, Object> remote = cacheFactory1.getHotRodCache(); assertNull(remote.withFlags(Flag.FORCE_RETURN_VALUE).put(key, value)); // 2. Remove with HotRod VersionedValue versioned = cacheFactory1.getHotRodCache().getVersioned(key); assertTrue(cacheFactory1.getHotRodCache().removeWithVersion(key, versioned.getVersion())); }
public void testHotRodRemove() throws Exception { final byte[] key = "7".getBytes(); final String value = "v1"; // 1. Put with HotRod RemoteCache<Object, Object> remote = cacheFactory1.getHotRodCache(); assertNull(remote.withFlags(Flag.FORCE_RETURN_VALUE).put(key, value)); // 2. Removed with HotRod VersionedValue versioned = cacheFactory1.getHotRodCache().getVersioned(key); assertTrue(cacheFactory1.getHotRodCache().removeWithVersion(key, versioned.getVersion())); }
@Test public void testReplaceWithVersion() { assertNull(remoteCache.replace("aKey", "aValue")); remoteCache.put("aKey", "aValue"); VersionedValue valueBinary = remoteCache.getVersioned("aKey"); // replacement should take place (and so return true) assertTrue(remoteCache.replaceWithVersion("aKey", "aNewValue", valueBinary.getVersion())); // version should have changed; value should have changed VersionedValue entry2 = remoteCache.getVersioned("aKey"); assertNotEquals(entry2.getVersion(), valueBinary.getVersion()); assertEquals(entry2.getValue(), "aNewValue"); // replacement should not take place because we have changed the value assertTrue(!remoteCache.replaceWithVersion("aKey", "aNewValue", valueBinary.getVersion())); }
@Test public void testRemoveWithVersion() { assertTrue(!remoteCache.removeWithVersion("aKey", 12321212l)); remoteCache.put("aKey", "aValue"); VersionedValue valueBinary = remoteCache.getVersioned("aKey"); assertTrue(remoteCache.removeWithVersion("aKey", valueBinary.getVersion())); remoteCache.put("aKey", "aNewValue"); VersionedValue entry2 = remoteCache.getVersioned("aKey"); assertNotEquals(entry2.getVersion(), valueBinary.getVersion()); assertEquals(entry2.getValue(), "aNewValue"); assertTrue(!remoteCache.removeWithVersion("aKey", valueBinary.getVersion())); }
public void testHotRodReplaceMemcachedCASTest() throws Exception { final String key1 = "6"; // 1. Put with Memcached Future<Boolean> f = cacheFactory.getMemcachedClient().set(key1, 0, "v1"); assertTrue(f.get(60, TimeUnit.SECONDS)); CASValue oldValue = cacheFactory.getMemcachedClient().gets(key1); // 2. Replace with Hot Rod VersionedValue versioned = cacheFactory.getHotRodCache().getVersioned(key1); assertTrue(cacheFactory.getHotRodCache().replaceWithVersion(key1, "v2", versioned.getVersion())); // 4. Get with Memcached and verify value/CAS CASValue newValue = cacheFactory.getMemcachedClient().gets(key1); assertEquals("v2", newValue.getValue()); assertTrue("The version (CAS) should have changed", oldValue.getCas() != newValue.getCas()); }
public void testHotRodRemoveConditionalEmbeddedGet() { final Integer key = 12; Cache<Integer, String> embedded = getEmbeddedCache(); RemoteCache<Integer, String> remote = cacheFactory.getHotRodCache(); assertEquals(null, remote.withFlags(Flag.FORCE_RETURN_VALUE).put(key, "v1")); VersionedValue<String> versioned = remote.getVersioned(key); assertFalse(remote.withFlags(Flag.FORCE_RETURN_VALUE).removeWithVersion(key, Long.MAX_VALUE)); assertTrue(remote.withFlags(Flag.FORCE_RETURN_VALUE).removeWithVersion(key, versioned.getVersion())); assertEquals(null, embedded.get(key)); }
public void testEmbeddedHotRodReplaceMemcachedCASTest() throws Exception { final String key1 = "7"; // 1. Put with Memcached Future<Boolean> f = cacheFactory.getMemcachedClient().set(key1, 0, "v1"); assertTrue(f.get(60, TimeUnit.SECONDS)); CASValue oldValue = cacheFactory.getMemcachedClient().gets(key1); // 2. Replace with Hot Rod VersionedValue versioned = cacheFactory.getHotRodCache().getVersioned(key1); assertTrue(cacheFactory.getHotRodCache().replaceWithVersion(key1, "v2", versioned.getVersion())); // 3. Replace with Embedded assertTrue(cacheFactory.getEmbeddedCache().replace(key1, "v2", "v3")); // 4. Get with Memcached and verify value/CAS CASValue newValue = cacheFactory.getMemcachedClient().gets(key1); assertEquals("v3", newValue.getValue()); assertTrue("The version (CAS) should have changed", oldValue.getCas() != newValue.getCas()); }
public void testHotRodReplaceConditionalEmbeddedGet() { final Integer key = 8; Cache<Integer, String> embedded = getEmbeddedCache(); RemoteCache<Integer, String> remote = cacheFactory.getHotRodCache(); assertEquals(null, remote.put(key, "v1")); VersionedValue<String> versioned = remote.getVersioned(key); assertEquals("v1", versioned.getValue()); assertTrue(0 != versioned.getVersion()); assertFalse(remote.replaceWithVersion(key, "v2", Long.MAX_VALUE)); assertTrue(remote.replaceWithVersion(key, "v2", versioned.getVersion())); assertEquals("v2", embedded.get(key)); assertEquals("v2", remote.withFlags(Flag.FORCE_RETURN_VALUE).remove(key)); }