@Override protected boolean updateCAS( final String storageKey, final CASValue<Object> casValue, final byte[] storageObject) throws ResourceIOException { final CASResponse casResult = client.cas(storageKey, casValue.getCas(), storageObject); return casResult == CASResponse.OK; }
@Override protected Cancellable updateCAS( final String storageKey, final CASValue<Object> casValue, final byte[] storageObject, final FutureCallback<Boolean> callback) { return operation(client.asyncCAS(storageKey, casValue.getCas(), storageObject), new FutureCallback<CASResponse>() { @Override public void completed(final CASResponse result) { callback.completed(result == CASResponse.OK); } @Override public void failed(final Exception ex) { callback.failed(ex); } @Override public void cancelled() { callback.cancelled(); } }); }
public Set<String> putIfUntouched(final Map<String, CasPut> values) { final Set<String> successes = new HashSet<>(); values.forEach((key, vals) -> { final long cas = ((SpyIdentifiableValue)vals.getIv()).getCasValue().getCas(); final CASResponse response = client.cas(key, cas, vals.getExpirationSeconds(), toCacheValue(vals.getNextToStore())); if (response == CASResponse.OK) { successes.add(key); } }); return successes; }
@Override protected boolean updateCAS( final String storageKey, final CASValue<Object> casValue, final byte[] storageObject) throws ResourceIOException { final CASResponse casResult = client.cas(storageKey, casValue.getCas(), storageObject); return casResult == CASResponse.OK; }
@Override protected Cancellable updateCAS( final String storageKey, final CASValue<Object> casValue, final byte[] storageObject, final FutureCallback<Boolean> callback) { return operation(client.asyncCAS(storageKey, casValue.getCas(), storageObject), new FutureCallback<CASResponse>() { @Override public void completed(final CASResponse result) { callback.completed(result == CASResponse.OK); } @Override public void failed(final Exception ex) { callback.failed(ex); } @Override public void cancelled() { callback.cancelled(); } }); }
public void testCas() throws Exception { MemcachedClient client = bootstrapClient(); client.add("caskey", 10, "casValue").get(); CASValue<Object> val = client.gets("caskey"); assertEquals("casValue", val.getValue()); CASResponse r = client.cas("caskey", val.getCas(), "newValue"); assertEquals(CASResponse.OK, r); r = client.cas("caskey", val.getCas(), "newValue2"); assertEquals(CASResponse.EXISTS, r); }
if(client.cas(key, casval.getCas(), rv, transcoder) == CASResponse.OK) { done=true;
if (client.cas(key, casval.getCas(), initialExp, rv, transcoder) == CASResponse.OK) { done = true;
public void testGets() throws Exception { MemcachedClient client = bootstrapClient(); client.add("getskey", 10, "casValue").get(); CASValue<Object> val = client.gets("getskey"); long oldCas = val.getCas(); assertEquals("casValue", val.getValue()); client.replace("getskey", 10, "myNewVal").get(); val = client.gets("getskey"); assertEquals(oldCas + 1, val.getCas()); assertEquals("myNewVal", val.getValue()); }
if (client.cas(key, casval.getCas(), initialExp, rv, transcoder) == CASResponse.OK) { done = true;
if(client.cas(key, casval.getCas(), rv, transcoder) == CASResponse.OK) { done=true;
/** {@inheritDoc} */ @Override public StorageRecord read(@Nonnull @NotEmpty final String context, @Nonnull @NotEmpty final String key) throws IOException { Constraint.isNotNull(StringSupport.trimOrNull(context), "Context cannot be null or empty"); Constraint.isNotNull(StringSupport.trimOrNull(key), "Key cannot be null or empty"); final String namespace = lookupNamespace(context); if (namespace == null) { logger.debug("Namespace for context {} does not exist", context); return null; } final String cacheKey = memcachedKey(namespace, key); logger.debug("Reading entry at {} for context={}, key={}", cacheKey, context, key); final CASValue<MemcachedStorageRecord> record; try { record = handleAsyncResult(memcacheClient.asyncGets(cacheKey, storageRecordTranscoder)); } catch (RuntimeException e) { throw new IOException("Memcached operation failed", e); } if (record == null) { return null; } record.getValue().setVersion(record.getCas()); return record.getValue(); }
public void testEmbeddedReplaceMemcachedCASTest() throws Exception { final String key1 = "5"; // 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 Embedded assertTrue(cacheFactory.getEmbeddedCache().replace(key1, "v1", "v2")); // 4. Get with Memcached and verify value/CAS CASValue newValue = cacheFactory.getMemcachedClient().gets(key1); assertEquals("v2", newValue.getValue()); assertNotSame("The version (CAS) should have changed, " + "oldCase=" + oldValue.getCas() + ", newCas=" + newValue.getCas(), oldValue.getCas(), newValue.getCas()); }
memcacheClient.asyncGets(cacheKey, storageRecordTranscoder)); if (newRecord != null) { newVersion = newRecord.getCas();
return new ObjectWithCas(retrieved.getValue(), retrieved.getCas());
final CASResponse casResult = client.cas(key, v.getCas(), updatedBytes); if (casResult != CASResponse.OK) {
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()); }
CASResponse casResult = client.cas(key, v.getCas(), updatedBytes); if (casResult != CASResponse.OK) {
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()); }
return SpyFutureHelper.fromCASResponse(() -> spyClient.asyncCAS(cacheKey, result.getCas(), newValue));