private Versioned<byte[]> incremented(Versioned<byte[]> versioned, int nodeId) { return new Versioned<byte[]>(versioned.getValue(), ((VectorClock) versioned.getVersion()).incremented(nodeId, time.getMilliseconds())); }
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; }
@Override public void put(K key, Versioned<V> value, T transforms) throws VoldemortException { value = value.cloneVersioned(); VectorClock clock = (VectorClock) value.getVersion(); clock.incrementVersion(nodeId, time.getMilliseconds()); super.put(key, value, transforms); }
public UpdateElementById(VListKey<K> key, Versioned<E> element) { _key = key; _element = element.getValue(); _version = element.getVersion(); }
@Override public void update(StoreClient<Map<String, Object>, Map<String, Object>> storeClient) { if(numCalls > 0) { // TODO jko maybe delete this if unnecessary Versioned<Map<String, Object>> nextNodeMap = storeClient.get(_key.mapValue()); if(nextNodeMap == null) throw new ObsoleteVersionException("possible concurrent modification"); _listNode = new Versioned<VListNode<E>>(VListNode.<E> valueOf(nextNodeMap.getValue()), nextNodeMap.getVersion()); } VListNode<E> nodeValue = _listNode.getValue(); _listNode.setObject(new VListNode<E>(nodeValue.getValue(), nodeValue.getId(), _newId, nodeValue.getNextId(), true)); Map<String, Object> nextNodeMap = _listNode.getValue().mapValue(); storeClient.put(_key.mapValue(), nextNodeMap); numCalls++; }
/** * An empty Versioned<V> value object is created and passed on to the actual * put operation. It defers the task of obtaining the existing Vector clock * to the Receiver of this request. */ @Override public Version put(K key, V value) { return put(key, new Versioned<V>(value)); }
@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); }
@SuppressWarnings("unchecked") public List<StoreDefinition> getRebalancingSourceStores() { // acquire read lock readLock.lock(); try { return (List<StoreDefinition>) metadataCache.get(REBALANCING_SOURCE_STORES_XML) .getValue(); } finally { readLock.unlock(); } }
public synchronized void fetchAndUpdateRemoteMetadata(int nodeId, String key, String value) { VectorClock currentClock = (VectorClock) getRemoteMetadata(nodeId, key).getVersion(); updateRemoteMetadata(nodeId, key, new Versioned<String>(Boolean.toString(false), currentClock.incremented(nodeId, 1))); }
@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);
Version obsoleteVersion = ((VectorClock) versionedValue.getVersion()).clone(); versionedValue.setObject("New Value !!!"); System.out.println("************* original version : " + versionedValue.getVersion()); Version putVersion = storeClient.put("a", versionedValue); System.out.println("************* Updated version : " + putVersion); Versioned<String> obsoleteVersionedValue = new Versioned<String>("Obsolete value", obsoleteVersion); try { Versioned<String> newVersionedPut = new Versioned<String>("Yet another value !!!", putVersion); storeClient.put("a", newVersionedPut);
@Override protected Versioned<Slop> computeNext() { try { Versioned<Slop> head = null; if(!shutDown) { head = slopQueue.take(); if(head.equals(END)) { shutDown = true; isComplete = true; } else { slopsDone++; if(slopsDone % voldemortConfig.getSlopBatchSize() == 0) { shutDown = true; } writeThrottler.maybeThrottle(writtenLast); writtenLast = slopSize(head); deleteBatch.add(Pair.create(head.getValue().makeKey(), (Version) head.getVersion())); return head; } } return endOfData(); } catch(Exception e) { logger.error("Got an exception " + e); return endOfData(); } }
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 List<Version> getVersions(String key) { List<Versioned<String>> values = get(key, (String) null); List<Version> versions = new ArrayList<Version>(values.size()); for(Versioned<?> value: values) { versions.add(value.getVersion()); } return versions; }
public void testClone() { Versioned<Integer> v1 = getVersioned(2, 1, 2, 3); Versioned<Integer> v2 = v1.cloneVersioned(); assertEquals(v1, v2); assertTrue(v1 != v2); assertTrue(v1.getVersion() != v2.getVersion()); ((VectorClock) v2.getVersion()).incrementVersion(1, System.currentTimeMillis()); assertTrue(!v1.equals(v2)); }
public void testEquals() { assertEquals("Null versioneds not equal.", getVersioned(null), getVersioned(null)); assertEquals("equal versioneds not equal.", getVersioned(1), getVersioned(1)); assertEquals("equal versioneds not equal.", getVersioned(1, 1, 2), getVersioned(1, 1, 2)); assertTrue("Equals values with different version are equal!", !getVersioned(1, 1, 2).equals(getVersioned(1, 1, 2, 2))); assertTrue("Different values with same version are equal!", !getVersioned(1, 1, 2).equals(getVersioned(2, 1, 2))); assertTrue("Different values with different version are equal!", !getVersioned(1, 1, 2).equals(getVersioned(2, 1, 1, 2))); // Should work for array types too! assertEquals("Equal arrays are not equal!", new Versioned<byte[]>(new byte[] { 1 }), new Versioned<byte[]>(new byte[] { 1 })); }
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); }
public void run() { boolean done = false; while(!done) { try { byte[] key = Integer.toString(index).getBytes(); List<Versioned<byte[]>> found = store.get(key, null); if(found.size() > 1) { throw new RuntimeException("Found multiple versions: " + found); } else if(found.size() == 1) { Versioned<byte[]> versioned = found.get(0); byte[] valueBytes = Integer.toString(MultithreadedStressTest.this.value.getAndIncrement()) .getBytes(); versioned.setObject(valueBytes); store.put(key, versioned, null); done = true; } else if(found.size() == 0) { throw new RuntimeException("No values found!"); } } catch(ObsoleteVersionException e) { obsoletes.getAndIncrement(); } finally { isDone.countDown(); } } } });