/** * Tests DeltaSequence.subList() on both empty and nonempty delta sequences. */ public void testSubList() { DeltaSequence empty = DeltaSequence.empty(); assertEquals(empty, empty.subList(0, 0)); DeltaSequence deltaseq = DeltaSequence.of(twoDeltas); assertEquals(twoDeltas, deltaseq.subList(0, twoDeltas.size())); assertEquals(empty, deltaseq.subList(0, 0)); // Construct a sublist with just the first delta. DeltaSequence subDeltas = deltaseq.subList(0, 1); assertEquals(START_VERSION + 5, subDeltas.getEndVersion().getVersion()); assertEquals(deltaseq.getStartVersion(), subDeltas.getStartVersion()); assertEquals(ImmutableList.of(delta1), subDeltas); }
@Override public String toString() { if (isEmpty()) { return "[DeltaSequence empty]"; } return "[DeltaSequence " + deltas.size() + " deltas, v " + getStartVersion() + " -> " + getEndVersion() + ": " + deltas + "]"; } }
public void testJoinValidSequencesAllowed() { DeltaSequence s1 = DeltaSequence.of(delta1); DeltaSequence s2 = DeltaSequence.of(delta2, delta3); DeltaSequence joined = DeltaSequence.join(s1, s2); assertEquals(delta1.getAppliedAtVersion(), joined.getStartVersion()); assertEquals(delta3.getResultingVersion(), joined.getEndVersion()); assertEquals(ImmutableList.of(delta1, delta2, delta3), joined); }
/** * Returns the {@link HashedVersion} of the wavelet after all deltas have been * applied. */ public HashedVersion getVersionAfterDeltas() { return deltas.isEmpty() ? snapshotAfterDeltas.getHashedVersion() : deltas.getEndVersion(); }
/** Creates a delta sequence by concatenating contiguous sequences. */ public static DeltaSequence join(DeltaSequence first, DeltaSequence... rest) { ImmutableList.Builder<TransformedWaveletDelta> builder = ImmutableList.builder(); builder.addAll(first); long expectedBeginVersion = first.getEndVersion().getVersion(); for (DeltaSequence s : rest) { Preconditions.checkArgument(s.getStartVersion() == expectedBeginVersion, "Sequences are not contiguous, expected start version %s for sequence %s", expectedBeginVersion, s); builder.addAll(s); expectedBeginVersion = s.getEndVersion().getVersion(); } return new DeltaSequence(builder.build(), false); }
public void testEmptySequence() { DeltaSequence empty = DeltaSequence.empty(); assertEquals(ImmutableList.<ProtocolWaveletDelta>of(), empty); assertTrue(empty.isEmpty()); assertEquals(0, empty.size()); try { empty.getStartVersion(); fail("Expected illegal state exception"); } catch (IllegalStateException expected) { } try { empty.getEndVersion(); fail("Expected illegal state exception"); } catch (IllegalStateException expected) { } }
public void testValidSequenceAllowed() { DeltaSequence deltaseq = DeltaSequence.of(twoDeltas); assertEquals(2, deltaseq.size()); assertEquals(START_VERSION, deltaseq.getStartVersion()); assertEquals(delta2.getResultingVersion(), deltaseq.getEndVersion()); }
/** * Tests that we get deltas. */ public void testReceivedDeltasSentToClient() throws Exception { CommittedWaveletSnapshot snapshot = provideWavelet(WN1); when(waveletProvider.getWaveletIds(WAVE_ID)).thenReturn(ImmutableSet.of(W1)); when(waveletProvider.checkAccessPermission(WN1, USER)).thenReturn(true); OpenListener listener = openWave(IdFilters.ALL_IDS); verify(listener).onUpdate(eq(WN1), eq(snapshot), eq(DeltaSequence.empty()), eq(V1), isNullMarker(), any(String.class)); verifyMarker(listener, WAVE_ID); TransformedWaveletDelta delta = TransformedWaveletDelta.cloneOperations(USER, V2, 1234567890L, Arrays.asList(UTIL.noOp())); DeltaSequence deltas = DeltaSequence.of(delta); clientFrontend.waveletUpdate(snapshot.snapshot, deltas); verify(listener).onUpdate(eq(WN1), isNullSnapshot(), eq(deltas), isNullVersion(), isNullMarker(), anyString()); }
if (newDeltas.isEmpty()) { return; for (int i = 0; i < newDeltas.size(); i++) { TransformedWaveletDelta delta = newDeltas.get(i); ParticipantId p = ((RemoveParticipant) op).getParticipantId(); remainingparticipants.remove(p); participantUpdate(waveletName, p, newDeltas.subList(0, i + 1), newParticipants.remove(p), true);
@Override public void waveletCommitted(WaveletName waveletName, HashedVersion version) { OpenListener listener = openListeners.get(waveletName.waveId); if (listener != null) { listener.onUpdate(waveletName, null, DeltaSequence.empty(), version, null, null); } }
/** * Appends the given deltas to the deltas already stored. Updates the latest * snapshot and latest version as well. This method will make a copy of the * snapshot. * * @param updatedSnapshot the snapshot after deltas have been applied * @param newDeltas the deltas that have been applied since the last call to * appendDeltas. */ public void appendDeltas(ReadableWaveletData updatedSnapshot, DeltaSequence newDeltas) { HashedVersion newEndVersion = newDeltas.getEndVersion(); Preconditions.checkArgument( !newDeltas.isEmpty(), "There were no new deltas passed to appendDeltas"); Preconditions.checkArgument(updatedSnapshot.getVersion() == newEndVersion.getVersion(), String.format("Version of snapshot %s doesn't match the HashedVersion %s", updatedSnapshot.getVersion(), newEndVersion)); Preconditions.checkArgument(areContiguousToCurrentVersion(newDeltas), String.format( "Deltas are not contiguous to the current version(%s) %s", getVersionAfterDeltas(), deltas)); WaveletName updatedWaveletName = WaveletDataUtil.waveletNameOf(updatedSnapshot); Preconditions.checkArgument(updatedWaveletName.equals(waveletName), String.format( "Updated wavelet doesn't have the same name as with which this class has been " + "instantiated. %s != %s", updatedWaveletName, waveletName)); // TODO(ljvderijk): This should actually be applying the deltas, however // they do not contain a timestamp at this time. snapshotAfterDeltas = WaveletDataUtil.copyWavelet(updatedSnapshot); deltas = DeltaSequence.join(deltas, newDeltas); }
@Override public boolean matches(Object sequence) { if (sequence != null) { DeltaSequence s = (DeltaSequence) sequence; return (s.size() > 0) && (s.getStartVersion() == version); } return false; } });
/** * Synchronizes the wavelet version and ensures that the deltas are * contiguous. * * @param waveletName the wavelet name. * @param newDeltas the new deltas. */ public void syncWaveletVersion(WaveletName waveletName, DeltaSequence newDeltas) { HashedVersion expectedVersion; PerWavelet waveletInfo = getWavelet(waveletName); synchronized (waveletInfo) { expectedVersion = waveletInfo.getCurrentVersion(); Preconditions.checkState(expectedVersion.getVersion() == newDeltas.getStartVersion(), "Expected deltas starting at version %s, got %s", expectedVersion, newDeltas.getStartVersion()); waveletInfo.setCurrentVersion(newDeltas.getEndVersion()); } }
ListReceiver<TransformedWaveletDelta> receiver = new ListReceiver<TransformedWaveletDelta>(); waveletState.getTransformedDeltaHistory(targetVersion, currentVersion, receiver); DeltaSequence serverDeltas = DeltaSequence.of(receiver); Preconditions.checkState(!serverDeltas.isEmpty(), "No deltas between valid versions %s and %s", targetVersion, currentVersion);
private static void assertJoinInvalid(DeltaSequence first, DeltaSequence... rest) { try { DeltaSequence.join(first, rest); fail("Expected delta sequence join to fail"); } catch (IllegalArgumentException expected) { } } }
/** * Checks the update targets the next expected version. */ private void checkUpdateVersion(WaveletName waveletName, DeltaSequence deltas, WaveletChannelState state) { if (state.lastVersion != null) { long expectedVersion = state.lastVersion.getVersion(); long targetVersion = deltas.getStartVersion(); Preconditions.checkState(targetVersion == expectedVersion, "Subscription expected delta for %s targeting %s, was %s", waveletName, expectedVersion, targetVersion); } }
/** * Receives additional deltas for the specified wavelet, of which we must be a * participant. Delta updates must be received in contiguous version order. */ public synchronized void onUpdate(WaveletName waveletName, DeltaSequence deltas) { Preconditions.checkNotNull(waveletName); if (deltas.isEmpty()) { return; } List<WaveViewSubscription> subscriptions = matchSubscriptions(waveletName); for (WaveViewSubscription subscription : subscriptions) { subscription.onUpdate(waveletName, deltas); } }
/** * Creates an empty delta sequence. This sequence will not have an end version. */ public static DeltaSequence empty() { return new DeltaSequence(ImmutableList.<TransformedWaveletDelta>of(), false); }
public void testEmptySequence() { DeltaSequence empty = DeltaSequence.empty(); assertEquals(ImmutableList.<ProtocolWaveletDelta>of(), empty); assertTrue(empty.isEmpty()); assertEquals(0, empty.size()); try { empty.getStartVersion(); fail("Expected illegal state exception"); } catch (IllegalStateException expected) { } try { empty.getEndVersion(); fail("Expected illegal state exception"); } catch (IllegalStateException expected) { } }