@Override public HashedVersion getAppliedAtVersion(long version) throws InvalidProtocolBufferException { WaveletDeltaRecord delta = getDelta(version); return (delta != null) ? delta.getAppliedAtVersion() : null; }
@Override public void appendDelta(WaveletDeltaRecord deltaRecord) throws OperationException { HashedVersion currentVersion = getCurrentVersion(); Preconditions.checkArgument(currentVersion.equals(deltaRecord.getAppliedAtVersion()), "Applied version %s doesn't match current version %s", deltaRecord.getAppliedAtVersion(), currentVersion); if (deltaRecord.getAppliedAtVersion().getVersion() == 0) { Preconditions.checkState(lastPersistedVersion.get() == null); snapshot = WaveletDataUtil.buildWaveletFromFirstDelta(getWaveletName(), deltaRecord.getTransformedDelta()); } else { WaveletDataUtil.applyWaveletDelta(deltaRecord.getTransformedDelta(), snapshot); } // Now that we built the snapshot without any exceptions, we record the delta. cachedDeltas.put(deltaRecord.getAppliedAtVersion(), deltaRecord); }
@Override public HashedVersion getHashedVersion(long version) { final Entry<HashedVersion, WaveletDeltaRecord> cachedEntry = lookupCached(cachedDeltas, version); if (version == 0) { return versionZero; } else if (snapshot == null) { return null; } else if (version == snapshot.getVersion()) { return snapshot.getHashedVersion(); } else { WaveletDeltaRecord delta; try { delta = lookup(version); } catch (IOException e) { throw new RuntimeIOException(new IOException(format("Version : %d", version), e)); } if (delta == null && cachedEntry != null) { return cachedEntry.getKey(); } else { return delta != null ? delta.getAppliedAtVersion() : null; } } }
public static DBObject serialize(WaveletDeltaRecord waveletDelta, String waveId, String waveletId) { BasicDBObject mongoWaveletDelta = new BasicDBObject(); mongoWaveletDelta.append(FIELD_WAVE_ID, waveId); mongoWaveletDelta.append(FIELD_WAVELET_ID, waveletId); mongoWaveletDelta.append(FIELD_APPLIEDATVERSION, serialize(waveletDelta.getAppliedAtVersion())); mongoWaveletDelta.append(FIELD_APPLIED, waveletDelta.getAppliedDelta().getByteArray()); mongoWaveletDelta.append(FIELD_TRANSFORMED, serialize(waveletDelta.getTransformedDelta())); return mongoWaveletDelta; }
private static void readDeltasInRange(WaveletDeltaRecordReader reader, ConcurrentNavigableMap<HashedVersion, WaveletDeltaRecord> cachedDeltas, HashedVersion startVersion, HashedVersion endVersion, Receiver<WaveletDeltaRecord> receiver) throws IOException { WaveletDeltaRecord delta = getDelta(reader, cachedDeltas, startVersion); Preconditions.checkArgument(delta != null && delta.getAppliedAtVersion().equals(startVersion), "invalid start version"); for (;;) { if (!receiver.put(delta)) { return; } if (delta.getResultingVersion().getVersion() >= endVersion.getVersion()) { break; } delta = getDelta(reader, cachedDeltas, delta.getResultingVersion()); if (delta == null) { break; } } Preconditions.checkArgument(delta != null && delta.getResultingVersion().equals(endVersion), "invalid end version"); }
deltas.add(deltaRecord); deltaResultingVersion = deltaRecord.getAppliedAtVersion();
@Override public WaveletDeltaRecord submitRequest(WaveletName waveletName, ProtocolSignedDelta signedDelta) throws OperationException, InvalidProtocolBufferException, InvalidHashException, PersistenceException, WaveletStateException { awaitLoad(); acquireWriteLock(); try { checkStateOk(); HashedVersion before = getCurrentVersion(); WaveletDeltaRecord result = transformAndApplyLocalDelta(signedDelta); HashedVersion after = getCurrentVersion(); // Only publish and persist the delta if it wasn't transformed away // (right now it never is since the current OT algorithm doesn't transform ops away) // and wasn't a duplicate of a previously applied delta. if (!after.equals(before)) { Preconditions.checkState(!result.isEmpty()); Preconditions.checkState(result.getAppliedAtVersion().equals(before)); ImmutableSet<String> domainsToNotify = domainsOf(Iterables.concat( accessSnapshot().getParticipants(), participantsRemovedBy(result.getTransformedDelta()))); notifyOfDeltas(ImmutableList.of(result), domainsToNotify); // We always persist a local delta immediately after it's applied // and after it's broadcast on the wave bus and to remote servers. persist(result.getResultingVersion(), domainsToNotify); } return result; } finally { releaseWriteLock(); } }
private void checkHistoryForDeltasWithInterrupt(final int interruptIndex, WaveletDeltaRecord... deltas) { HashedVersion beginVersion = deltas[0].getAppliedAtVersion(); HashedVersion endVersion = deltas[interruptIndex].getTransformedDelta().getResultingVersion();
private void checkHistoryForDeltasWithInterrupt(final int interruptIndex, WaveletDeltaRecord... deltas) { HashedVersion beginVersion = deltas[0].getAppliedAtVersion(); HashedVersion endVersion = deltas[interruptIndex].getTransformedDelta().getResultingVersion();
/** * Checks that a request for the deltas spanning a contiguous sequence of * delta facets produces correct results. */ private void checkHistoryForDeltas(WaveletDeltaRecord... deltas) { HashedVersion beginVersion = deltas[0].getAppliedAtVersion(); HashedVersion endVersion = deltas[deltas.length - 1].getTransformedDelta().getResultingVersion(); { List<TransformedWaveletDelta> expected = Lists.newArrayListWithExpectedSize(deltas.length); for (WaveletDeltaRecord d : deltas) { expected.add(d.getTransformedDelta()); } ListReceiver<TransformedWaveletDelta> transformedDeltasReceiver = new ListReceiver<TransformedWaveletDelta>(); target.getTransformedDeltaHistory(beginVersion, endVersion, transformedDeltasReceiver); assertTrue(Iterables.elementsEqual(expected, transformedDeltasReceiver)); } { List<ByteStringMessage<ProtocolAppliedWaveletDelta>> expected = Lists.newArrayListWithExpectedSize(deltas.length); for (WaveletDeltaRecord d : deltas) { expected.add(d.getAppliedDelta()); } ListReceiver<ByteStringMessage<Proto.ProtocolAppliedWaveletDelta>> appliedDeltasReceiver = new ListReceiver<ByteStringMessage<Proto.ProtocolAppliedWaveletDelta>>(); target.getAppliedDeltaHistory(beginVersion, endVersion, appliedDeltasReceiver); assertTrue(Iterables.elementsEqual(expected, appliedDeltasReceiver)); } }
/** * Checks that a request for the deltas spanning a contiguous sequence of * delta facets produces correct results. */ private void checkHistoryForDeltas(WaveletDeltaRecord... deltas) { HashedVersion beginVersion = deltas[0].getAppliedAtVersion(); HashedVersion endVersion = deltas[deltas.length - 1].getTransformedDelta().getResultingVersion(); { List<TransformedWaveletDelta> expected = Lists.newArrayListWithExpectedSize(deltas.length); for (WaveletDeltaRecord d : deltas) { expected.add(d.getTransformedDelta()); } ListReceiver<TransformedWaveletDelta> transformedDeltasReceiver = new ListReceiver<TransformedWaveletDelta>(); target.getTransformedDeltaHistory(beginVersion, endVersion, transformedDeltasReceiver); assertTrue(Iterables.elementsEqual(expected, transformedDeltasReceiver)); } { List<ByteStringMessage<ProtocolAppliedWaveletDelta>> expected = Lists.newArrayListWithExpectedSize(deltas.length); for (WaveletDeltaRecord d : deltas) { expected.add(d.getAppliedDelta()); } ListReceiver<ByteStringMessage<Proto.ProtocolAppliedWaveletDelta>> appliedDeltasReceiver = new ListReceiver<ByteStringMessage<Proto.ProtocolAppliedWaveletDelta>>(); target.getAppliedDeltaHistory(beginVersion, endVersion, appliedDeltasReceiver); assertTrue(Iterables.elementsEqual(expected, appliedDeltasReceiver)); } }
public void testWriteToNewWavelet() throws Exception { Pair<DeltaStore,WaveletDeltaRecord> pair = newDeltaStoreWithRecord(WAVE1_WAVELET1); DeltaStore store = pair.first; WaveletDeltaRecord record = pair.second; DeltasAccess wavelet = store.open(WAVE1_WAVELET1); assertFalse(wavelet.isEmpty()); assertEquals(WAVE1_WAVELET1, wavelet.getWaveletName()); assertEquals(record.getResultingVersion(), wavelet.getEndVersion()); assertEquals(record, wavelet.getDelta(0)); assertEquals(record, wavelet.getDeltaByEndVersion(record.getResultingVersion().getVersion())); assertEquals(record.getAppliedAtVersion(), wavelet.getAppliedAtVersion(0)); assertEquals(record.getAppliedDelta(), wavelet.getAppliedDelta(0)); assertEquals(record.getTransformedDelta(), wavelet.getTransformedDelta(0)); wavelet.close(); }
public void testWriteToNewWavelet() throws Exception { Pair<DeltaStore,WaveletDeltaRecord> pair = newDeltaStoreWithRecord(WAVE1_WAVELET1); DeltaStore store = pair.first; WaveletDeltaRecord record = pair.second; DeltasAccess wavelet = store.open(WAVE1_WAVELET1); assertFalse(wavelet.isEmpty()); assertEquals(WAVE1_WAVELET1, wavelet.getWaveletName()); assertEquals(record.getResultingVersion(), wavelet.getEndVersion()); assertEquals(record, wavelet.getDelta(0)); assertEquals(record, wavelet.getDeltaByEndVersion(record.getResultingVersion().getVersion())); assertEquals(record.getAppliedAtVersion(), wavelet.getAppliedAtVersion(0)); assertEquals(record.getAppliedDelta(), wavelet.getAppliedDelta(0)); assertEquals(record.getTransformedDelta(), wavelet.getTransformedDelta(0)); wavelet.close(); }