Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.waveprotocol.box.server.waveserver; import com.google.common.base.Function; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Iterables; import com.google.common.util.concurrent.ListenableFuture; import com.google.protobuf.ByteString; import com.google.protobuf.InvalidProtocolBufferException; import org.waveprotocol.box.server.common.CoreWaveletOperationSerializer; import org.waveprotocol.box.server.persistence.PersistenceException; import org.waveprotocol.wave.federation.Proto.ProtocolAppliedWaveletDelta; import org.waveprotocol.wave.federation.Proto.ProtocolSignature; import org.waveprotocol.wave.federation.Proto.ProtocolSignedDelta; import org.waveprotocol.wave.federation.Proto.ProtocolWaveletDelta; import org.waveprotocol.wave.model.id.WaveletName; import org.waveprotocol.wave.model.operation.OperationException; import org.waveprotocol.wave.model.operation.wave.RemoveParticipant; import org.waveprotocol.wave.model.operation.wave.TransformedWaveletDelta; import org.waveprotocol.wave.model.operation.wave.WaveletDelta; import org.waveprotocol.wave.model.operation.wave.WaveletOperation; import org.waveprotocol.wave.model.version.HashedVersion; import org.waveprotocol.wave.model.wave.ParticipantId; import org.waveprotocol.wave.util.logging.Log; import java.util.concurrent.Executor; /** * A local wavelet may be updated by submits. The local wavelet will perform * operational transformation on the submitted delta and assign it the latest * version of the wavelet. */ class LocalWaveletContainerImpl extends WaveletContainerImpl implements LocalWaveletContainer { private static final Log LOG = Log.get(LocalWaveletContainerImpl.class); private static final Function<RemoveParticipant, ParticipantId> PARTICIPANT_REMOVED_BY = new Function<RemoveParticipant, ParticipantId>() { @Override public ParticipantId apply(RemoveParticipant op) { return op.getParticipantId(); } }; private static final Function<ParticipantId, String> DOMAIN_OF = new Function<ParticipantId, String>() { @Override public String apply(ParticipantId participant) { return participant.getDomain(); } }; private static Iterable<ParticipantId> participantsRemovedBy(Iterable<WaveletOperation> ops) { return Iterables.transform(Iterables.filter(ops, RemoveParticipant.class), PARTICIPANT_REMOVED_BY); } private static ImmutableSet<String> domainsOf(Iterable<ParticipantId> participants) { return ImmutableSet.copyOf(Iterables.transform(participants, DOMAIN_OF)); } public LocalWaveletContainerImpl(WaveletName waveletName, WaveletNotificationSubscriber notifiee, ListenableFuture<? extends WaveletState> waveletStateFuture, String waveDomain, Executor storageContinuationExecutor) { super(waveletName, notifiee, waveletStateFuture, waveDomain, storageContinuationExecutor); } @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(); } } /** * Apply a signed delta to a local wavelet. This assumes the caller has * validated that the delta is at the correct version and can be applied to * the wavelet. Must be called with writelock held. * * @param signedDelta the delta that is to be applied to wavelet. * @return the transformed and applied delta. * @throws OperationException if an error occurs during transformation or * application * @throws InvalidProtocolBufferException if the signed delta did not contain a valid delta * @throws InvalidHashException if delta hash sanity checks fail */ private WaveletDeltaRecord transformAndApplyLocalDelta(ProtocolSignedDelta signedDelta) throws OperationException, InvalidProtocolBufferException, InvalidHashException, PersistenceException { ProtocolWaveletDelta protocolDelta = ByteStringMessage.parseProtocolWaveletDelta(signedDelta.getDelta()) .getMessage(); Preconditions.checkArgument(protocolDelta.getOperationCount() > 0, "empty delta"); WaveletDelta transformed = maybeTransformSubmittedDelta( CoreWaveletOperationSerializer.deserialize(protocolDelta)); // TODO(ljvderijk): a Clock needs to be injected here (Issue 104) long applicationTimestamp = System.currentTimeMillis(); HashedVersion currentVersion = getCurrentVersion(); // This is always false right now because the current algorithm doesn't transform ops away. if (transformed.size() == 0) { Preconditions.checkState(currentVersion.getVersion() != 0, "currentVersion can not be 0 if delta was transformed"); Preconditions.checkState(transformed.getTargetVersion().getVersion() <= currentVersion.getVersion()); // The delta was transformed away. That's OK but we don't call either // applyWaveletOperations(), because that will throw IllegalArgumentException, or // commitAppliedDelta(), because empty deltas cannot be part of the delta history. TransformedWaveletDelta emptyDelta = new TransformedWaveletDelta(transformed.getAuthor(), transformed.getTargetVersion(), applicationTimestamp, transformed); return new WaveletDeltaRecord(transformed.getTargetVersion(), null, emptyDelta); } if (!transformed.getTargetVersion().equals(currentVersion)) { Preconditions.checkState(transformed.getTargetVersion().getVersion() < currentVersion.getVersion()); // The delta was a duplicate of an existing server delta. // We duplicate-eliminate it (don't apply it to the wavelet state and don't store it in // the delta history) and return the server delta which it was a duplicate of // (so delta submission becomes idempotent). ByteStringMessage<ProtocolAppliedWaveletDelta> existingDeltaBytes = lookupAppliedDelta( transformed.getTargetVersion()); TransformedWaveletDelta dupDelta = lookupTransformedDelta(transformed.getTargetVersion()); LOG.info("Duplicate delta " + dupDelta + " for wavelet " + getWaveletName()); // TODO(anorth): Replace these comparisons with methods on delta classes. Preconditions.checkState(dupDelta.getAuthor().equals(transformed.getAuthor()), "Duplicate delta detected but mismatched author, expected %s found %s", transformed.getAuthor(), dupDelta.getAuthor()); Preconditions.checkState(Iterables.elementsEqual(dupDelta, transformed), "Duplicate delta detected but mismatched ops, expected %s found %s", transformed, dupDelta); return new WaveletDeltaRecord(transformed.getTargetVersion(), existingDeltaBytes, dupDelta); } // Build the applied delta to commit ByteStringMessage<ProtocolAppliedWaveletDelta> appliedDelta = AppliedDeltaUtil.buildAppliedDelta( signedDelta, transformed.getTargetVersion(), transformed.size(), applicationTimestamp); return applyDelta(appliedDelta, transformed); } @Override public boolean isDeltaSigner(HashedVersion version, ByteString signerId) { ByteStringMessage<ProtocolAppliedWaveletDelta> appliedDelta = lookupAppliedDeltaByEndVersion(version); if (appliedDelta == null) { return false; } ProtocolSignedDelta signedDelta = appliedDelta.getMessage().getSignedOriginalDelta(); for (ProtocolSignature signature : signedDelta.getSignatureList()) { if (signature.getSignerId().equals(signerId)) return true; } return false; } }