public boolean isExpired(long expiredTimeMs) { return ((VectorClock) innerVersion).getTimestamp() < expiredTimeMs; }
public boolean isExpired(long expiredTimeMs) { return ((VectorClock) version).getTimestamp() < expiredTimeMs; }
public boolean isTimeStampLaterThan(Value currentLatest) { if (!(currentLatest instanceof HashedValue)) { throw new VoldemortException( " Expected type HashedValue found type " + currentLatest.getClass().getCanonicalName()); } HashedValue latestVersion = (HashedValue) currentLatest; long latestTimeStamp = ((VectorClock) latestVersion.innerVersion).getTimestamp(); long myTimeStamp = ((VectorClock) innerVersion).getTimestamp(); return myTimeStamp > latestTimeStamp; } }
public boolean isTimeStampLaterThan(Value currentLatest) { if (!(currentLatest instanceof VersionValue)) { throw new VoldemortException( " Expected type VersionValue found type " + currentLatest.getClass().getCanonicalName()); } VersionValue latestVersion = (VersionValue) currentLatest; long latestTimeStamp = ((VectorClock) latestVersion.version).getTimestamp(); long myTimeStamp = ((VectorClock) version).getTimestamp(); return myTimeStamp > latestTimeStamp; } }
@Override public String toString() { StringBuilder record = new StringBuilder(); record.append(((VectorClock) version).getTimestamp() + ","); record.append(version.toString().replaceAll(", ", ";").replaceAll(" ts:[0-9]*", "") .replaceAll("version\\((.*)\\)", "[$1]")); return record.toString(); }
private void updateKeyCounters(Version v) { if(!(v instanceof VectorClock)) throw new IllegalArgumentException("Cannot compare Versions of different types."); VectorClock vClock = (VectorClock) v; long timeStamp = vClock.getTimestamp(); if(isTimeStampInitialized == false) { isTimeStampInitialized = true; minTimeStamp = timeStamp; maxTimeStamp = timeStamp; } else { minTimeStamp = Math.min(minTimeStamp, timeStamp); maxTimeStamp = Math.max(maxTimeStamp, timeStamp); } }
@Override public String toString() { StringBuilder record = new StringBuilder(); record.append(((VectorClock) innerVersion).getTimestamp() + ","); record.append(innerVersion.toString().replaceAll(", ", ";").replaceAll(" ts:[0-9]*", "") .replaceAll("version\\((.*)\\)", "[$1],")); record.append(valueHash); return record.toString(); }
public VectorClockWrapper(VectorClock vc) { this.versions = vc.getEntries(); this.setTimestamp(vc.getTimestamp()); }
/** * Function to copy values from another VectorClock. This is used for * in-place updates during a Voldemort put operation. * * @param vc The VectorClock object from which the inner values are to be * copied. */ public void copyFromVectorClock(VectorClock vc) { this.versionMap.clear(); this.timestamp = vc.getTimestamp(); for(ClockEntry clockEntry: vc.getEntries()) { this.versionMap.put(clockEntry.getNodeId(), clockEntry.getVersion()); } } }
public List<Versioned<T>> resolveConflicts(List<Versioned<T>> items) { if(items.size() <= 1) { return items; } else { Versioned<T> max = items.get(0); long maxTime = ((VectorClock) items.get(0).getVersion()).getTimestamp(); VectorClock maxClock = ((VectorClock) items.get(0).getVersion()); for(Versioned<T> versioned: items) { VectorClock clock = (VectorClock) versioned.getVersion(); if(clock.getTimestamp() > maxTime) { max = versioned; maxTime = ((VectorClock) versioned.getVersion()).getTimestamp(); } maxClock = maxClock.merge(clock); } Versioned<T> maxTimeClockVersioned = new Versioned<T>(max.getValue(), maxClock); return Collections.singletonList(maxTimeClockVersioned); } }
/** * Performs the filtering of the expired entries based on retention time. * Optionally, deletes them also * * @param key the key whose value is to be deleted if needed * @param vals set of values to be filtered out * @return filtered list of values which are currently valid */ private List<Versioned<byte[]>> filterExpiredEntries(ByteArray key, List<Versioned<byte[]>> vals) { Iterator<Versioned<byte[]>> valsIterator = vals.iterator(); while(valsIterator.hasNext()) { Versioned<byte[]> val = valsIterator.next(); VectorClock clock = (VectorClock) val.getVersion(); // omit if expired if(clock.getTimestamp() < (time.getMilliseconds() - this.retentionTimeMs)) { valsIterator.remove(); // delete stale value if configured if(deleteExpiredEntries) { getInnerStore().delete(key, clock); } } } return vals; }
/** * Record events for the given sequence of nodes * * @param clock The VectorClock to record the events on * @param nodes The sequences of node events */ public static void increment(VectorClock clock, int... nodes) { for(int n: nodes) clock.incrementVersion((short) n, clock.getTimestamp()); }
/** * Remove all non replica clock entries from the list of versioned values * provided * * @param vals list of versioned values to prune replicas from * @param keyReplicas list of current replicas for the given key * @param didPrune flag to mark if we did actually prune something * @return pruned list */ public static List<Versioned<byte[]>> pruneNonReplicaEntries(List<Versioned<byte[]>> vals, List<Integer> keyReplicas, MutableBoolean didPrune) { List<Versioned<byte[]>> prunedVals = new ArrayList<Versioned<byte[]>>(vals.size()); for(Versioned<byte[]> val: vals) { VectorClock clock = (VectorClock) val.getVersion(); List<ClockEntry> clockEntries = new ArrayList<ClockEntry>(); for(ClockEntry clockEntry: clock.getEntries()) { if(keyReplicas.contains((int) clockEntry.getNodeId())) { clockEntries.add(clockEntry); } else { didPrune.setValue(true); } } prunedVals.add(new Versioned<byte[]>(val.getValue(), new VectorClock(clockEntries, clock.getTimestamp()))); } return prunedVals; }
for(Versioned<byte[]> versioned: handle.getValues()) { VectorClock storedClock = (VectorClock) versioned.getVersion(); if(storedClock.getTimestamp() >= streamedClock.getTimestamp()) { foundGreaterTs = true; break;
new VectorClock(((VectorClock) resolvedVersioned.getVersion()).getTimestamp())); Versioned<byte[]> resolvedVersioned = resolvedVals.get(0); Versioned<byte[]> newEntry = new Versioned<byte[]>(resolvedVersioned.getValue(), new VectorClock(((VectorClock) resolvedVersioned.getVersion()).getTimestamp())); streamingPut(prevKey, newEntry);
public static VProto.VectorClock.Builder encodeClock(Version version) { VectorClock clock = (VectorClock) version; VProto.VectorClock.Builder encoded = VProto.VectorClock.newBuilder(); encoded.setTimestamp(clock.getTimestamp()); for(ClockEntry entry: clock.getEntries()) encoded.addEntries(VProto.ClockEntry.newBuilder() .setNodeId(entry.getNodeId()) .setVersion(entry.getVersion())); return encoded; }
public void testGetVersionRequest(ByteArray key, byte[] value, VectorClock version, boolean isPresent) throws Exception { try { if(isPresent) { testPutRequest(key, value, null, version, null, false); } ByteArrayOutputStream getVersionRequest = new ByteArrayOutputStream(); this.clientWireFormat.writeGetVersionRequest(new DataOutputStream(getVersionRequest), storeName, key, RequestRoutingType.NORMAL); ByteArrayOutputStream getVersionResponse = handleRequest(getVersionRequest); testIsCompleteGetVersionResponse(getVersionResponse); List<Version> values = this.clientWireFormat.readGetVersionResponse(inputStream(getVersionResponse)); if(isPresent) { assertEquals(1, values.size()); VectorClock returnValue = (VectorClock) values.get(0); assertEquals(version, returnValue); assertEquals(version.getTimestamp(), returnValue.getTimestamp()); } else { assertEquals(0, values.size()); } } finally { this.store.deleteAll(); } }
onlineClock1.getTimestamp(), ((VectorClock) resolvedVersions.get(0).getVersion()).getTimestamp()); assertEquals("Online value to be read out", new String(onlineVal),
resolvedVals.get(0).getVersion()); assertEquals("Incorrect winning version", clock1.getTimestamp(), ((VectorClock) resolvedVals.get(0).getVersion()).getTimestamp());
System.currentTimeMillis()); VectorClock winningClock = new VectorClock(Lists.newArrayList(new ClockEntry((short) 1, 5)), losingClock.getTimestamp() + 1); srcAdminClient.storeOps.putNodeKeyValue(MULTIPLE_VERSIONS_STORE_NAME, new NodeValue<ByteArray, byte[]>(masterNode,