/**
   * 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);
  }
예제 #2
0
/** @author [email protected] (Soren Lassen) */
public class WaveletDataUtilTest extends TestCase {
  public static final ParticipantId CREATOR = new ParticipantId("*****@*****.**");
  public static final ParticipantId JOE = new ParticipantId("*****@*****.**");
  public static final WaveletName WAVELET_NAME =
      WaveletName.of(WaveId.of("example.com", "w+wave"), WaveletId.of("example.com", "wavelet"));

  private WaveletOperationContext opContext(long timestamp, HashedVersion version) {
    return new WaveletOperationContext(CREATOR, timestamp, 1L, version);
  }

  private WaveletOperation addParticipant(ParticipantId user, long time, HashedVersion version) {
    return new AddParticipant(opContext(time, version), user);
  }

  private WaveletOperation addBlip(String id, long time, HashedVersion version) {
    return new WaveletBlipOperation(
        id, new BlipContentOperation(opContext(time, version), new DocOpBuilder().build()));
  }

  private TransformedWaveletDelta delta(WaveletOperation... ops) {
    WaveletOperation last = ops[ops.length - 1];
    WaveletOperationContext ctx = last.getContext();
    return new TransformedWaveletDelta(
        ctx.getCreator(), ctx.getHashedVersion(), ctx.getTimestamp(), Arrays.asList(ops));
  }

  private ObservableWaveletData build(TransformedWaveletDelta... deltas) throws OperationException {
    return WaveletDataUtil.buildWaveletFromDeltas(WAVELET_NAME, Arrays.asList(deltas).iterator());
  }

  public void testBuildWaveletFromOneDelta() throws Exception {
    WaveletData wavelet = build(delta(addParticipant(CREATOR, 1093L, HashedVersion.unsigned(1))));
    assertEquals(WAVELET_NAME, WaveletDataUtil.waveletNameOf(wavelet));
    assertEquals(CREATOR, wavelet.getCreator());
    assertEquals(1093L, wavelet.getCreationTime());
    assertEquals(1093L, wavelet.getLastModifiedTime());
    assertEquals(HashedVersion.unsigned(1), wavelet.getHashedVersion());
    assertEquals(ImmutableSet.of(), wavelet.getDocumentIds());
    assertEquals(ImmutableSet.of(CREATOR), wavelet.getParticipants());
  }

  public void testBuildWaveletFromThreeDeltas() throws Exception {
    WaveletData wavelet =
        build(
            delta(addParticipant(CREATOR, 1093L, HashedVersion.unsigned(1))),
            delta(addParticipant(JOE, 1492L, HashedVersion.unsigned(2))),
            delta(addBlip("blipid", 2010L, HashedVersion.unsigned(3))));
    assertEquals(WAVELET_NAME, WaveletDataUtil.waveletNameOf(wavelet));
    assertEquals(CREATOR, wavelet.getCreator());
    assertEquals(1093L, wavelet.getCreationTime());
    assertEquals(2010L, wavelet.getLastModifiedTime());
    assertEquals(HashedVersion.unsigned(3), wavelet.getHashedVersion());
    assertEquals(ImmutableSet.of("blipid"), wavelet.getDocumentIds());
    assertEquals(ImmutableSet.of(CREATOR, JOE), wavelet.getParticipants());
  }
}
 private <T extends WaveletContainer> T getWavelet(
     WaveletId waveletId, ConcurrentMap<WaveletId, T> waveletsMap) throws WaveletStateException {
   ImmutableSet<WaveletId> storedWavelets;
   try {
     storedWavelets =
         FutureUtil.getResultOrPropagateException(lookedupWavelets, PersistenceException.class);
   } catch (PersistenceException e) {
     throw new WaveletStateException(
         "Failed to lookup wavelet " + WaveletName.of(waveId, waveletId), e);
   } catch (InterruptedException e) {
     Thread.currentThread().interrupt();
     throw new WaveletStateException(
         "Interrupted looking up wavelet " + WaveletName.of(waveId, waveletId), e);
   }
   // Since waveletsMap is a computing map, we must call containsKey(waveletId)
   // to tell if waveletId is mapped, we cannot test if get(waveletId) returns null.
   if (!storedWavelets.contains(waveletId) && !waveletsMap.containsKey(waveletId)) {
     return null;
   } else {
     T wavelet = waveletsMap.get(waveletId);
     Preconditions.checkNotNull(wavelet, "computingMap returned null");
     return wavelet;
   }
 }
 @Override
 public T apply(WaveletId waveletId) {
   return factory.create(notifiee, WaveletName.of(waveId, waveletId), waveDomain);
 }
 private WaveletName getFakeWaveletName(String domain) {
   return WaveletName.of(WaveId.of(domain, "wave"), WaveletId.of(domain, "wavelet"));
 }
/**
 * Tests for {@link WaveletState} implementations.
 *
 * @author [email protected] (Alex North)
 */
public abstract class WaveletStateTestBase extends TestCase {

  private static final WaveletName NAME =
      WaveletName.of(WaveId.of("example.com", "waveid"), WaveletId.of("example.com", "waveletid"));
  private static final ParticipantId AUTHOR = ParticipantId.ofUnsafe("*****@*****.**");
  private static final DeltaTestUtil UTIL = new DeltaTestUtil(AUTHOR);
  private static final long TS = 1234567890L;
  private static final long TS2 = TS + 1;
  private static final long TS3 = TS2 + 1;

  private static final IdURIEncoderDecoder URI_CODEC = new IdURIEncoderDecoder(new JavaUrlCodec());
  private static final HashedVersionFactory HASH_FACTORY = new HashedVersionFactoryImpl(URI_CODEC);
  private static final HashedVersion V0 = HASH_FACTORY.createVersionZero(NAME);

  /** Creates a new, empty wavelet state. */
  protected abstract WaveletState createEmptyState(WaveletName name) throws Exception;

  /**
   * Waits for all pending persistence operations to be completed. All persistence listener
   * callbacks must be completed before this method returns.
   */
  protected abstract void awaitPersistence() throws Exception;

  private WaveletDeltaRecord d1;
  private WaveletDeltaRecord d2;
  private WaveletDeltaRecord d3;

  private WaveletState target;

  @Override
  public void setUp() throws Exception {
    d1 = makeDelta(V0, TS, 2);
    d2 = makeDelta(d1.getResultingVersion(), TS2, 2);
    d3 = makeDelta(d2.getResultingVersion(), TS3, 1);

    target = createEmptyState(NAME);
  }

  public void testReportsWaveletName() {
    assertEquals(NAME, target.getWaveletName());
  }

  public void testEmptyStateIsEmpty() {
    assertNull(target.getSnapshot());
    assertEquals(V0, target.getCurrentVersion());
    assertEquals(V0, target.getHashedVersion(0));

    assertNull(target.getTransformedDelta(V0));
    assertNull(target.getAppliedDelta(V0));
  }

  public void testSnapshotMetadataReflectsDeltas() throws Exception {
    HashedVersion v2 = d1.getResultingVersion();
    appendDeltas(d1);

    assertEquals(v2, target.getCurrentVersion());
    ReadableWaveletData snapshot = target.getSnapshot();
    assertEquals(AUTHOR, snapshot.getCreator());
    assertEquals(v2, snapshot.getHashedVersion());
    assertEquals(TS, snapshot.getCreationTime());
    assertEquals(TS, snapshot.getLastModifiedTime());
    assertEquals(2, snapshot.getVersion());

    HashedVersion v4 = d2.getResultingVersion();
    appendDeltas(d2);

    assertEquals(v4, target.getCurrentVersion());
    snapshot = target.getSnapshot();
    assertEquals(v4, snapshot.getHashedVersion());
    assertEquals(4, snapshot.getVersion());
    // Last-modified-time doesn't change due to unworthiness.
  }

  public void testHashedVersionAccessibleOnDeltaBoundaries() throws Exception {
    appendDeltas(d1, d2, d3);
    assertEquals(V0, target.getHashedVersion(0));
    assertEquals(d1.getResultingVersion(), target.getHashedVersion(2));
    assertEquals(d2.getResultingVersion(), target.getHashedVersion(4));
    assertEquals(d3.getResultingVersion(), target.getHashedVersion(5));
    assertNull(target.getHashedVersion(1));
    assertNull(target.getHashedVersion(3));
    assertNull(target.getHashedVersion(6));
  }

  public void testDeltasAccessibleByBeginVersion() throws Exception {
    appendDeltas(d1, d2, d3);
    assertEquals(d1.transformed, target.getTransformedDelta(V0));
    assertEquals(d1.applied, target.getAppliedDelta(V0));

    assertEquals(d2.transformed, target.getTransformedDelta(d1.getResultingVersion()));
    assertEquals(d2.applied, target.getAppliedDelta(d1.getResultingVersion()));

    assertEquals(d3.transformed, target.getTransformedDelta(d2.getResultingVersion()));
    assertEquals(d3.applied, target.getAppliedDelta(d2.getResultingVersion()));

    // Wrong hashes return null.
    assertNull(target.getTransformedDelta(HashedVersion.unsigned(0)));
    assertNull(target.getAppliedDelta(HashedVersion.unsigned(0)));
  }

  public void testDeltasAccesssibleByEndVersion() throws Exception {
    appendDeltas(d1, d2, d3);
    for (WaveletDeltaRecord d : Arrays.asList(d1, d2, d3)) {
      assertEquals(d.transformed, target.getTransformedDeltaByEndVersion(d.getResultingVersion()));
      assertEquals(d.applied, target.getAppliedDeltaByEndVersion(d.getResultingVersion()));
    }

    // Wrong hashes return null.
    assertNull(
        target.getTransformedDeltaByEndVersion(
            HashedVersion.unsigned(d1.getResultingVersion().getVersion())));
    assertNull(
        target.getAppliedDeltaByEndVersion(
            HashedVersion.unsigned(d1.getResultingVersion().getVersion())));
  }

  public void testDeltaHistoryRequiresCorrectHash() throws Exception {
    appendDeltas(d1);

    // Wrong start hash.
    assertNull(
        target.getTransformedDeltaHistory(HashedVersion.unsigned(0), d1.getResultingVersion()));
    assertNull(target.getAppliedDeltaHistory(HashedVersion.unsigned(0), d1.getResultingVersion()));

    // Wrong end hash.
    assertNull(
        target.getTransformedDeltaHistory(
            V0, HashedVersion.unsigned(d1.getResultingVersion().getVersion())));
    assertNull(
        target.getAppliedDeltaHistory(
            V0, HashedVersion.unsigned(d1.getResultingVersion().getVersion())));
  }

  public void testSingleDeltaHistoryAccessible() throws Exception {
    appendDeltas(d1);
    DeltaSequence transformedHistory =
        target.getTransformedDeltaHistory(V0, d1.getResultingVersion());
    assertNotNull(transformedHistory);
    assertEquals(1, transformedHistory.size());
    assertEquals(d1.transformed, transformedHistory.get(0));

    Collection<ByteStringMessage<ProtocolAppliedWaveletDelta>> appliedHistory =
        target.getAppliedDeltaHistory(V0, d1.getResultingVersion());
    assertNotNull(appliedHistory);
    assertEquals(1, appliedHistory.size());
    assertEquals(d1.applied, Iterables.getOnlyElement(appliedHistory));
  }

  public void testDeltaHistoryQueriesCorrectHistory() throws Exception {
    appendDeltas(d1, d2, d3);

    checkHistoryForDeltas(d1);
    checkHistoryForDeltas(d1, d2);
    checkHistoryForDeltas(d2, d3);
    checkHistoryForDeltas(d1, d2, d3);
  }

  /**
   * 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].appliedAtVersion;
    HashedVersion endVersion = deltas[deltas.length - 1].transformed.getResultingVersion();

    {
      List<TransformedWaveletDelta> expected = Lists.newArrayListWithExpectedSize(deltas.length);
      for (WaveletDeltaRecord d : deltas) {
        expected.add(d.transformed);
      }
      assertEquals(expected, target.getTransformedDeltaHistory(beginVersion, endVersion));
    }
    {
      List<ByteStringMessage<ProtocolAppliedWaveletDelta>> expected =
          Lists.newArrayListWithExpectedSize(deltas.length);
      for (WaveletDeltaRecord d : deltas) {
        expected.add(d.applied);
      }
      assertTrue(
          Iterables.elementsEqual(
              expected, target.getAppliedDeltaHistory(beginVersion, endVersion)));
    }
  }

  public void checkSingleDeltaPersistFutureDone() throws Exception {
    appendDeltas(d1);
    Future<Void> future = target.persist(d1.getResultingVersion());
    awaitPersistence();
    assertTrue(future.isDone());
    assertEquals(null, future.get());
    assertEquals(d1.getResultingVersion(), target.getLastPersistedVersion());
  }

  public void checkManyDeltasPersistFutureDone() throws Exception {
    appendDeltas(d1, d2, d3);
    Future<Void> future = target.persist(d3.getResultingVersion());
    awaitPersistence();
    assertTrue(future.isDone());
    assertEquals(null, future.get());
    assertEquals(d3.getResultingVersion(), target.getLastPersistedVersion());
  }

  public void testCanPersistOnlySomeDeltas() throws Exception {
    appendDeltas(d1, d2, d3);
    Future<Void> future = target.persist(d2.getResultingVersion());
    awaitPersistence();
    assertTrue(future.isDone());
    assertEquals(null, future.get());
    assertEquals(d2.getResultingVersion(), target.getLastPersistedVersion());

    future = target.persist(d3.getResultingVersion());
    awaitPersistence();
    assertTrue(future.isDone());
    assertEquals(null, future.get());
    assertEquals(d3.getResultingVersion(), target.getLastPersistedVersion());
  }

  /** Applies a delta to the target. */
  private void appendDeltas(WaveletDeltaRecord... deltas)
      throws InvalidProtocolBufferException, OperationException {
    for (WaveletDeltaRecord delta : deltas) {
      target.appendDelta(delta.appliedAtVersion, delta.transformed, delta.applied);
    }
  }

  /**
   * Creates a delta of no-ops and builds the corresponding applied and transformed delta objects.
   */
  private static WaveletDeltaRecord makeDelta(
      HashedVersion appliedAtVersion, long timestamp, int numOps)
      throws InvalidProtocolBufferException {
    // Use no-op delta so the ops can actually apply.
    WaveletDelta delta = UTIL.makeNoOpDelta(appliedAtVersion, timestamp, numOps);
    ByteStringMessage<ProtocolAppliedWaveletDelta> appliedDelta =
        WaveServerTestUtil.buildAppliedDelta(delta, timestamp);
    TransformedWaveletDelta transformedDelta =
        AppliedDeltaUtil.buildTransformedDelta(appliedDelta, delta);
    return new WaveletDeltaRecord(appliedAtVersion, appliedDelta, transformedDelta);
  }
}