public Version put(K key, V value) { Version version = getVersionForPut(key); Versioned<V> versioned = Versioned.value(value, version); return put(key, versioned); }
public Version put(K key, V value, Object transforms) { Version version = getVersionForPut(key); Versioned<V> versioned = Versioned.value(value, version); return put(key, versioned, transforms); }
@Override public void setUp() { target1.put("hello", Versioned.value("world"), null); Integer[] values1 = { 1, 2, 3, 4, 5, 6, 7, 8 }; Integer[] values2 = { 100, 200, 300, 400, 500, 600, 700 }; target2.put(1, Versioned.value(Arrays.asList(values1)), null); target2.put(100, Versioned.value(Arrays.asList(values2)), null); }
public Version putSysStore(K key, V value) { Version version = null; try { if(logger.isDebugEnabled()) { logger.debug("Invoking Put for key : " + key + " on store name : " + this.storeName); } Versioned<V> versioned = getSysStore(key); if(versioned == null) versioned = Versioned.value(value, new VectorClock()); else versioned.setObject(value); this.sysStore.put(key, versioned, null); version = versioned.getVersion(); } catch(Exception e) { if(logger.isDebugEnabled()) { logger.debug("Exception caught during putSysStore: " + e); } } return version; }
public void run() { while(keepRunning.get()) { byte[] bytes = Integer.toString(count.getAndIncrement()).getBytes(); store.put(new ByteArray(bytes), Versioned.value(bytes), null); count.incrementAndGet(); } } });
public static List<Versioned<byte[]>> fromByteArray(byte[] bytes) { if(bytes.length < 1) throw new VoldemortException("Invalid value length: " + bytes.length); if(bytes[0] != VERSION) throw new VoldemortException("Unexpected version number in value: " + bytes[0]); int pos = 1; List<Versioned<byte[]>> vals = new ArrayList<Versioned<byte[]>>(2); while(pos < bytes.length) { VectorClock clock = new VectorClock(bytes, pos); pos += clock.sizeInBytes(); int valueSize = ByteUtils.readInt(bytes, pos); pos += ByteUtils.SIZE_OF_INT; byte[] val = new byte[valueSize]; System.arraycopy(bytes, pos, val, 0, valueSize); pos += valueSize; vals.add(Versioned.value(val, clock)); } if(pos != bytes.length) throw new VoldemortException((bytes.length - pos) + " straggling bytes found in value (this should not be possible)!"); return vals; }
private Versioned<Slop> randomSlop(String name, int nodeId) { return Versioned.value(new Slop(name, Operation.PUT, TestUtils.randomBytes(10), TestUtils.randomBytes(10), nodeId, new Date())); }
public void testGetAll() { target1.put("a", Versioned.value("a"), null); target1.put("b", Versioned.value("b"), null); Map<String, List<Versioned<String>>> found = valView.getAll(ImmutableList.of("a", "b"), ImmutableMap.of("a", "concat", "b", "concat")); assertTrue(found.containsKey("a")); assertTrue(found.containsKey("b")); assertEquals("a42", found.get("a").get(0).getValue()); assertEquals("b42", found.get("b").get(0).getValue()); }
@Override public void put(ByteArray key, Versioned<byte[]> value, byte[] transforms) throws VoldemortException { if(valueCompressionStrategy != null) value = inflateValue(value); Versioned<byte[]> result = Versioned.value(valueFromViewSchema(key, value.getValue(), transforms), value.getVersion()); if(valueCompressionStrategy != null) result = deflateValue(result); target.put(key, result, null); }
public void testPutWithTransforms() { Integer[] values1 = { 9, 90, 10, 15, 25, 106 }; Integer[] filter1 = { 1, 10 }; Versioned<List<Integer>> values = Versioned.value(Arrays.asList(values1)); VectorClock clock = (VectorClock) values.getVersion(); clock.incrementVersion(0, System.currentTimeMillis()); view.put(1, Versioned.value(values.getValue(), clock), Arrays.asList(filter1)); assertEquals(10, view.get(1, Arrays.asList(filter1)).get(0).getValue().size()); Integer[] filter2 = { 5, 10 }; assertEquals(6, view.get(1, Arrays.asList(filter2)).get(0).getValue().size()); Version updatedVersion = view.get(1, Arrays.asList(filter2)).get(0).getVersion(); Integer[] filter3 = { 1, 50 }; Integer[] values2 = { 90, 15, 25, 106 }; clock = (VectorClock) updatedVersion; VectorClock clock1 = clock.incremented(0, System.currentTimeMillis()); view.put(1, Versioned.value(Arrays.asList(values2), clock1), Arrays.asList(filter3)); assertEquals(12, view.get(1, Arrays.asList(filter3)).get(0).getValue().size()); }
@Override public void doOperation(int index) { try { String key = Integer.toString(index); List<Versioned<byte[]>> vs = store.get(key, null); VectorClock version; if(vs.size() == 0) version = new VectorClock(); else version = (VectorClock) vs.get(0).getVersion(); version.incrementVersion(0, 847584375); store.put(key, Versioned.value(value, version), null); } catch(ObsoleteVersionException e) { // do nothing } catch(RuntimeException e) { e.printStackTrace(); throw e; } } }, recents, numValues, cacheHitRatio);
public void testPut() { valView.put("abc", Versioned.value("cde"), null); assertEquals("c", target1.get("abc", null).get(0).getValue()); }
/** * Util function to test getAll with one node down * * @param store The Routed store object used to perform the put and getall * @throws Exception */ private void getAllWithNodeDown(Store<ByteArray, byte[], byte[]> store) throws Exception { Map<ByteArray, byte[]> expectedValues = Maps.newHashMap(); for(byte i = 1; i < 11; ++i) { ByteArray key = new ByteArray(new byte[] { i }); byte[] value = new byte[] { (byte) (i + 50) }; store.put(key, Versioned.value(value), null); expectedValues.put(key, value); } recordException(failureDetector, cluster.getNodes().iterator().next()); Map<ByteArray, List<Versioned<byte[]>>> all = store.getAll(expectedValues.keySet(), null); assertEquals(expectedValues.size(), all.size()); for(Map.Entry<ByteArray, List<Versioned<byte[]>>> mapEntry: all.entrySet()) { byte[] value = expectedValues.get(mapEntry.getKey()); assertEquals(new ByteArray(value), new ByteArray(mapEntry.getValue().get(0).getValue())); } }
@Override protected Pair<ByteArray, Versioned<byte[]>> computeNext() { Pair<ByteArray, Versioned<byte[]>> p = inner.next(); Versioned<byte[]> newVal = Versioned.value(valueToViewSchema(p.getFirst(), p.getSecond().getValue(), null), p.getSecond().getVersion()); return Pair.create(p.getFirst(), newVal); } }
@Test public void testGetVersions() throws Exception { List<K> keys = getKeys(2); K key = keys.get(0); V value = getValue(); Store<K, V, T> store = getStore(); store.put(key, Versioned.value(value), null); List<Versioned<V>> versioneds = store.get(key, null); List<Version> versions = store.getVersions(key); assertEquals(1, versioneds.size()); assertTrue(versions.size() > 0); for(int i = 0; i < versions.size(); i++) assertEquals(versioneds.get(0).getVersion(), versions.get(i)); assertEquals(0, store.getVersions(keys.get(1)).size()); }
@Test public void testGetVersions2() throws Exception { List<ByteArray> keys = getKeys(2); ByteArray key = keys.get(0); byte[] value = getValue(); Store<ByteArray, byte[], byte[]> store = getStore(); store.put(key, Versioned.value(value), null); List<Versioned<byte[]>> versioneds = store.get(key, null); List<Version> versions = store.getVersions(key); assertEquals(1, versioneds.size()); assertEquals(9, versions.size()); for(int i = 0; i < versions.size(); i++) assertEquals(versioneds.get(0).getVersion(), versions.get(i)); assertEquals(0, store.getVersions(keys.get(1)).size()); }
@Test public void testGetVersions2ZZZ() throws Exception { List<ByteArray> keys = getKeys(2); ByteArray key = keys.get(0); byte[] value = getValue(); Store<ByteArray, byte[], byte[]> store = getZonedStore(); store.put(key, Versioned.value(value), null); List<Versioned<byte[]>> versioneds = store.get(key, null); List<Version> versions = store.getVersions(key); assertEquals(1, versioneds.size()); assertEquals(9, versions.size()); for(int i = 0; i < versions.size(); i++) assertEquals(versioneds.get(0).getVersion(), versions.get(i)); assertEquals(0, store.getVersions(keys.get(1)).size()); }
@Override @Test public void testGetVersions() throws Exception { List<ByteArray> keys = getKeys(2); ByteArray key = keys.get(0); byte[] value = getValue(); VectorClock vc = getClock(0, 0); Store<ByteArray, byte[], byte[]> store = getStore(); store.put(key, Versioned.value(value, vc), null); List<Versioned<byte[]>> versioneds = store.get(key, null); List<Version> versions = store.getVersions(key); assertEquals(1, versioneds.size()); assertTrue(versions.size() > 0); for(int i = 0; i < versions.size(); i++) assertEquals(versioneds.get(0).getVersion(), versions.get(i)); assertEquals(0, store.getVersions(keys.get(1)).size()); }
/** * Test the new put that returns the new version */ @Test public void testPutReturnVersion() { Version baseVersion = new VectorClock(); Version oldVersion = null; Version newVersion = null; Versioned<String> getVersioned = null; String oldValue = null; String newValue = null; for(int i = 0; i < 5; i++) { oldValue = "value" + i; newValue = "value" + (i + 1); oldVersion = storeClient.put("key1", Versioned.value(oldValue, baseVersion)); newVersion = storeClient.put("key1", Versioned.value(newValue, ((VectorClock) oldVersion).clone())); getVersioned = storeClient.get("key1"); baseVersion = newVersion; verifyResults(oldVersion, newVersion, getVersioned, newValue); } }
@Test public void testPutVersioned() { client.put("k", Versioned.value("v")); Versioned<String> v = client.get("k"); assertEquals("GET should return the version set by PUT.", "v", v.getValue()); VectorClock expected = new VectorClock(); expected.incrementVersion(nodeId, time.getMilliseconds()); assertEquals("The version should be incremented after a put.", expected, v.getVersion()); try { client.put("k", Versioned.value("v")); fail("Put of obsolete version should throw exception."); } catch(ObsoleteVersionException e) { // this is good } // PUT of a concurrent version should succeed client.put("k", new Versioned<String>("v2", new VectorClock().incremented(nodeId + 1, time.getMilliseconds()))); assertEquals("GET should return the new value set by PUT.", "v2", client.getValue("k")); assertEquals("GET should return the new version set by PUT.", expected.incremented(nodeId + 1, time.getMilliseconds()), client.get("k").getVersion()); }