@DataProvider(name = "sizeMatchData") public Object[][] sizeMatchData() { return new Object[][] { { 10, 100, -1, -1, null }, { 20, 313, -1, -1, null }, { 10, 100, 4000, -1, null }, { 20, 313, -1, 10000, null }, { 10, 100, 4000, -1, new NumericVersion(1003)}, { 20, 313, -1, 10000, new NumericVersion(81418) }, { 10, 100, 4000, 738141, null}, { 20, 313, 14141, 10000, new NumericVersion(8417) }, }; }
public static long extractVersion(CacheEntry ce) { if (ce == null) return -1; EntryVersion entryVersion = ce.getMetadata().version(); long version = 0; if (entryVersion != null) { if (entryVersion instanceof NumericVersion) { version = NumericVersion.class.cast(entryVersion).getVersion(); } if (entryVersion instanceof SimpleClusteredVersion) { version = SimpleClusteredVersion.class.cast(entryVersion).getVersion(); } } return version; }
public void testConditionalReplaceWithVersion() { final Integer key = 2; NumericVersion version = new NumericVersion(1); advCache.put(key, "v1", withVersion(version)); NumericVersion newVersion = new NumericVersion(2); advCache.replace(key, "v1", "v2", withVersion(newVersion)); CacheEntry cacheEntry = advCache.getCacheEntry(key); assertEquals(EQUAL, newVersion.compareTo(cacheEntry.getMetadata().version())); }
@Override public Void apply(ReadWriteEntryView<K, String> rw) { rw.set("one", new MetaEntryVersion(new NumericVersion(100))); return null; }
public void testReplaceWithVersion() { final Integer key = 7; NumericVersion version = new NumericVersion(1); advCache.put(key, "v1", withVersion(version)); NumericVersion newVersion = new NumericVersion(2); advCache.replace(key, "v2", withVersion(newVersion)); CacheEntry cacheEntry = advCache.getCacheEntry(key); assertEquals(EQUAL, newVersion.compareTo(cacheEntry.getMetadata().version())); }
private ByteBuf buildSingleGetWithVersionResponse(byte[] k, CacheEntry<byte[], byte[]> entry) { byte[] v = entry.getValue(); // TODO: Would be nice for EntryVersion to allow retrieving the version itself... byte[] version = String.valueOf(((NumericVersion) entry.getMetadata().version()).getVersion()).getBytes(); ByteBuf buf = buildGetHeaderBegin(k, entry, version.length + 1 + END_SIZE); buf.writeByte(SP); // 1 buf.writeBytes(version); // version.length writeGetHeaderData(v, buf); return writeGetHeaderEnd(buf); }
@Test public void testDuplicateParametersOnConstruction() { MetaEntryVersion versionParam1 = new MetaEntryVersion(new NumericVersion(100)); MetaEntryVersion versionParam2 = new MetaEntryVersion(new NumericVersion(200)); MetaParams metas = MetaParams.of(versionParam1, versionParam2); assertEquals(1, metas.size()); assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(200))), metas.find(MetaEntryVersion.class)); }
public void testPutWithVersion() { final Integer key = 1; NumericVersion version = new NumericVersion(1); advCache.put(key, "v1", withVersion(version)); CacheEntry cacheEntry = advCache.getCacheEntry(key); assertEquals(EQUAL, version.compareTo(cacheEntry.getMetadata().version())); }
@Override public byte[] convert(byte[] key, byte[] oldValue, Metadata oldMetadata, byte[] newValue, Metadata newMetadata, EventType eventType) { int capacity = UnsignedNumeric.sizeUnsignedInt(key.length) + key.length + (newValue != null ? UnsignedNumeric.sizeUnsignedInt(newValue.length) + newValue.length + 8 : 0); if (newValue == null && returnOldValue && oldValue != null) { capacity += UnsignedNumeric.sizeUnsignedInt(oldValue.length) + oldValue.length + 8; } byte[] out = new byte[capacity]; int offset = UnsignedNumeric.writeUnsignedInt(out, 0, key.length); offset += putBytes(key, offset, out); if (newValue != null) { offset += UnsignedNumeric.writeUnsignedInt(out, offset, newValue.length); offset += putBytes(newValue, offset, out); putLong(((NumericVersion) newMetadata.version()).getVersion(), offset, out); } if (newValue == null && returnOldValue && oldValue != null) { offset += UnsignedNumeric.writeUnsignedInt(out, offset, oldValue.length); offset += putBytes(oldValue, offset, out); putLong(((NumericVersion) newMetadata.version()).getVersion(), offset, out); } return out; }
@Override public ReadWriteEntryView<K, String> apply(ReadWriteEntryView<K, String> rw) { Optional<MetaEntryVersion> metaParam = rw.findMetaParam(MetaEntryVersion.class); metaParam.ifPresent(metaVersion -> { if (metaVersion.get().compareTo(new NumericVersion(version)) == EQUAL) rw.set("uno", new MetaEntryVersion(new NumericVersion(200))); }); return rw; }
public void testPutIfAbsentWithVersion() { final Integer key = 3; NumericVersion version = new NumericVersion(1); assertEquals(null, advCache.putIfAbsent(key, "v1", withVersion(version))); CacheEntry cacheEntry = advCache.getCacheEntry(key); assertEquals(EQUAL, version.compareTo(cacheEntry.getMetadata().version())); }
private long serverDataVersion(byte[] k, Cache cache) { CacheEntry cacheEntry = cache.getAdvancedCache().getCacheEntry(k); Metadata metadata = cacheEntry.getMetadata(); EntryVersion version = metadata.version(); return ((NumericVersion) version).getVersion(); }
@Test public void testDuplicateParametersOnAdd() { MetaEntryVersion versionParam1 = new MetaEntryVersion(new NumericVersion(100)); MetaParams metas = MetaParams.of(versionParam1); assertEquals(1, metas.size()); assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(100))), metas.find(MetaEntryVersion.class)); MetaEntryVersion versionParam2 = new MetaEntryVersion(new NumericVersion(200)); metas.add(versionParam2); assertEquals(1, metas.size()); assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(200))), metas.find(MetaEntryVersion.class)); MetaEntryVersion versionParam3 = new MetaEntryVersion(new NumericVersion(300)); MetaEntryVersion versionParam4 = new MetaEntryVersion(new NumericVersion(400)); metas.addMany(versionParam3, versionParam4); assertEquals(1, metas.size()); assertEquals(Optional.of(new MetaEntryVersion(new NumericVersion(400))), metas.find(MetaEntryVersion.class)); }
public void testPutAsyncWithVersion() throws Exception { final Integer key = 4; NumericVersion version = new NumericVersion(1); Future<String> f = advCache.putAsync(key, "v1", withVersion(version)); assertNotNull(f); assertFalse(f.isCancelled()); assertNull(f.get()); assertTrue(f.isDone()); CacheEntry entry = advCache.getCacheEntry(key); assertEquals("v1", entry.getValue()); assertEquals(EQUAL, version.compareTo(entry.getMetadata().version())); }
@CacheEntryCreated @CacheEntryModified @CacheEntryRemoved @CacheEntryExpired public void onCacheEvent(CacheEntryEvent<byte[], byte[]> event) { if (isSendEvent(event)) { long version; Metadata metadata; if ((metadata = event.getMetadata()) != null && metadata.version() != null) { version = ((NumericVersion) metadata.version()).getVersion(); } else { version = 0; } Object k = event.getKey(); Object v = event.getValue(); sendEvent((byte[]) k, (byte[]) v, version, event); } }
public void testPrimaryOwnerChangingDuringReplaceBasedOnMeta() throws Exception { // TODO: Move initial set and replace with meta logic to TestWriteOperation WriteOnlyMap<String, String> wo0 = wo(0); wo0.eval("testkey", wo -> wo.set("v0", new MetaEntryVersion(new NumericVersion(1)))); doTest(TestWriteOperation.REPLACE_META_FUNCTIONAL); }
long version; if (numericVersion != null) { version = numericVersion.getVersion(); } else { version = 0;
@Test public void testAddFindMultipleMetaParams() { MetaParams metas = MetaParams.empty(); metas.addMany(new MetaLifespan(1000), new MetaMaxIdle(1000), new MetaEntryVersion(new NumericVersion(12345))); assertFalse(metas.isEmpty()); assertEquals(3, metas.size()); Optional<MetaMaxIdle> maxIdle = metas.find(MetaMaxIdle.class); Optional<MetaEntryVersion> entryVersion = metas.find(MetaEntryVersion.class); assertEquals(Optional.of(new MetaMaxIdle(1000)), maxIdle); assertFalse(900 == maxIdle.get().get().longValue()); assertEquals(new MetaEntryVersion(new NumericVersion(12345)), entryVersion.get()); assertFalse(new MetaEntryVersion(new NumericVersion(23456)).equals(entryVersion.get())); }
@Override protected Object perform(TestWriteOperation op, AdvancedCache<Object, Object> cache0, String key) { try { return super.perform(op, cache0, key); } catch (IllegalArgumentException e) { switch (op) { case REPLACE_META_FUNCTIONAL: return FunctionalTestUtils.await(rw(cache0).eval(key, "v1", (v, rw) -> { return rw.findMetaParam(MetaEntryVersion.class) .filter(ver -> ver.get().compareTo(new NumericVersion(1)) == EQUAL) .map(ver -> { rw.set(v, new MetaEntryVersion(new NumericVersion(2))); return true; }).orElse(false); })); default: throw new AssertionError("Unknown operation: " + op); } } }
private void handleGetForRemoveIfUnmodified(HotRodHeader header, AdvancedCache<byte[], byte[]> cache, CacheEntry<byte[], byte[]> entry, byte[] key, long version, Throwable throwable) { if (throwable != null) { writeException(header, throwable); } else if (entry != null) { byte[] prev = entry.getValue(); NumericVersion streamVersion = new NumericVersion(version); if (entry.getMetadata().version().equals(streamVersion)) { cache.removeAsync(key, prev).whenComplete((removed, throwable2) -> { if (throwable2 != null) { writeException(header, throwable2); } else if (removed) { writeSuccess(header, prev); } else { writeNotExecuted(header, prev); } }); } else { writeNotExecuted(header, prev); } } else { writeNotExist(header); } }