@Override public void onSuccess(int operationsApplied, ProtocolHashedVersion hashedVersionAfterApplication, long applicationTimestamp) { listener.onSuccess(operationsApplied, CoreWaveletOperationSerializer.deserialize(hashedVersionAfterApplication), applicationTimestamp); } });
private static ProtocolWaveletDelta serialize(WaveletDelta d) { return CoreWaveletOperationSerializer.serialize(d); } }
/** * Assert that an operation is unchanged when serialised then deserialised. * * @param op operation to check */ private static void assertReversible(WaveletOperation op) { // Test both (de)serialising a single operation... assertEquals(op, CoreWaveletOperationSerializer.deserialize( CoreWaveletOperationSerializer.serialize(op), OP_CONTEXT)); List<WaveletOperation> ops = ImmutableList.of(op, op, op); ParticipantId author = new ParticipantId("kalman@google.com"); HashedVersion hashedVersion = HashedVersion.unsigned(0); WaveletDelta delta = new WaveletDelta(author, hashedVersion, ops); ProtocolWaveletDelta serialized = CoreWaveletOperationSerializer.serialize(delta); WaveletDelta deserialized = CoreWaveletOperationSerializer.deserialize(serialized); assertEquals(hashedVersion.getVersion(), serialized.getHashedVersion().getVersion()); assertTrue(Arrays.equals(hashedVersion.getHistoryHash(), serialized.getHashedVersion().getHistoryHash().toByteArray())); assertDeepEquals(delta, deserialized); }
/** * Assert that an operation is unchanged when serialised then deserialised. * * @param op operation to check */ private static void assertReversible(WaveletOperation op) { // Test both (de)serialising a single operation... assertEquals(op, CoreWaveletOperationSerializer.deserialize( CoreWaveletOperationSerializer.serialize(op), OP_CONTEXT)); List<WaveletOperation> ops = ImmutableList.of(op, op, op); ParticipantId author = new ParticipantId("kalman@google.com"); HashedVersion hashedVersion = HashedVersion.unsigned(0); WaveletDelta delta = new WaveletDelta(author, hashedVersion, ops); ProtocolWaveletDelta serialized = CoreWaveletOperationSerializer.serialize(delta); WaveletDelta deserialized = CoreWaveletOperationSerializer.deserialize(serialized); assertEquals(hashedVersion.getVersion(), serialized.getHashedVersion().getVersion()); assertTrue(Arrays.equals(hashedVersion.getHistoryHash(), serialized.getHashedVersion().getHistoryHash().toByteArray())); assertDeepEquals(delta, deserialized); }
private static ProtocolWaveletDelta serialize(WaveletDelta d) { return CoreWaveletOperationSerializer.serialize(d); } }
private static DocOp deserializeDocOp(DBObject dbObject) throws PersistenceException { try { return CoreWaveletOperationSerializer.deserialize(ProtocolDocumentOperation .parseFrom(((byte[]) dbObject.get(FIELD_BYTES)))); } catch (InvalidProtocolBufferException e) { throw new PersistenceException(e); } } }
private static ProtocolHashedVersion serialize(HashedVersion v) { return CoreWaveletOperationSerializer.serialize(v); }
/** * Deserializes a {@link ProtocolWaveletDelta} as an untransformed wavelet * delta. */ public static WaveletDelta deserialize(ProtocolWaveletDelta delta) { List<WaveletOperation> ops = Lists.newArrayList(); for (ProtocolWaveletOperation op : delta.getOperationList()) { WaveletOperationContext context = new WaveletOperationContext( ParticipantId.ofUnsafe(delta.getAuthor()), Constants.NO_TIMESTAMP, 1); ops.add(deserialize(op, context)); } HashedVersion hashedVersion = deserialize(delta.getHashedVersion()); return new WaveletDelta(new ParticipantId(delta.getAuthor()), hashedVersion, ops); }
private static ProtocolHashedVersion serialize(HashedVersion v) { return CoreWaveletOperationSerializer.serialize(v); }
/** * Deserializes a {@link ProtocolWaveletDelta} as a transformed wavelet delta. */ public static TransformedWaveletDelta deserialize(ProtocolWaveletDelta delta, HashedVersion resultingVersion, long applicationTimestamp) { ParticipantId author = ParticipantId.ofUnsafe(delta.getAuthor()); int count = delta.getOperationCount(); Preconditions.checkArgument(count > 0, "Cannot deserialize an empty delta"); List<WaveletOperation> ops = Lists.newArrayListWithCapacity(count); if (count > 1) { WaveletOperationContext context = new WaveletOperationContext(author, applicationTimestamp, 1); for (int i = 0; i < count - 1; i++) { ProtocolWaveletOperation op = delta.getOperation(i); ops.add(deserialize(op, context)); } } WaveletOperationContext context = new WaveletOperationContext(author, applicationTimestamp, 1, resultingVersion); ops.add(deserialize(delta.getOperation(count - 1), context)); return new TransformedWaveletDelta(author, resultingVersion, applicationTimestamp, ops); }
@Override public boolean put(TransformedWaveletDelta delta) { ProtocolWaveletDelta protoDelta = CoreWaveletOperationSerializer.serialize(delta); byte[] bytes = protoDelta.toByteArray(); deltaBytes.add(bytes); version.set(delta.getResultingVersion()); return length.addAndGet(bytes.length) < GET_HISTORY_BYTES_LENGTH_LIMIT; } });
/** * Creates the non-existent remote wavelet container at this server and commits it. * Calling commit at this known version, forces the history to be fetched up to this point. * TODO (alown): Possible race condition here with update? (Though I don't think it would result in * anything more serious than repeated history fetches.) */ private void createAndCommitRemoteWavelet(WaveletName waveletName, ProtocolHashedVersion committedVersion) { RemoteWaveletContainer wavelet = getOrCreateRemoteWavelet(waveletName); HashedVersion v = CoreWaveletOperationSerializer.deserialize(committedVersion); wavelet.commit(v); LOG.info("Passed commit message for version " + v.getVersion() + " to RemoteWavelet"); }
public static DBObject serialize(DocOp docOp) { BasicDBObject mongoDocOp = new BasicDBObject(); mongoDocOp.append(FIELD_BYTES, CoreWaveletOperationSerializer.serialize(docOp).toByteArray()); return mongoDocOp; }
private HashedVersion getVersionParameter(OperationRequest operation, ParamsProperty parameter) throws InvalidRequestException { byte[] bytes = OperationUtil.<byte[]>getRequiredParameter( operation, parameter); ProtocolHashedVersion protoVersion; try { protoVersion = ProtocolHashedVersion.parseFrom(bytes); } catch (InvalidProtocolBufferException ex) { throw new InvalidRequestException("Invalid version " + parameter.key(), operation, ex); } return CoreWaveletOperationSerializer.deserialize(protoVersion); } }
private void getDeltas(OperationContext context, WaveletName waveletName, ParticipantId participant, HashedVersion fromVersion, HashedVersion toVersion, RawDeltasListener listener) throws InvalidRequestException { final List<byte[]> deltaBytes = new LinkedList<byte[]>(); final AtomicReference<HashedVersion> version = new AtomicReference<HashedVersion>(); final AtomicInteger length = new AtomicInteger(0); context.getDeltas(waveletName, participant, fromVersion, toVersion, new Receiver<TransformedWaveletDelta>() { @Override public boolean put(TransformedWaveletDelta delta) { ProtocolWaveletDelta protoDelta = CoreWaveletOperationSerializer.serialize(delta); byte[] bytes = protoDelta.toByteArray(); deltaBytes.add(bytes); version.set(delta.getResultingVersion()); return length.addAndGet(bytes.length) < GET_HISTORY_BYTES_LENGTH_LIMIT; } }); listener.onSuccess(deltaBytes, CoreWaveletOperationSerializer.serialize(version.get()).toByteArray()); }
/** * Deserialize a {@link ProtoTransformedWaveletDelta} into a {@link TransformedWaveletDelta} */ public static TransformedWaveletDelta deserialize(ProtoTransformedWaveletDelta delta) { long applicationTimestamp = delta.getApplicationTimestamp(); HashedVersion resultingVersion = CoreWaveletOperationSerializer.deserialize(delta.getResultingVersion()); ParticipantId author = ParticipantId.ofUnsafe(delta.getAuthor()); ImmutableList.Builder<WaveletOperation> operations = ImmutableList.builder(); int numOperations = delta.getOperationCount(); for (int i = 0; i < numOperations; i++) { WaveletOperationContext context; if (i == numOperations - 1) { context = new WaveletOperationContext(author, applicationTimestamp, 1, resultingVersion); } else { context = new WaveletOperationContext(author, applicationTimestamp, 1); } operations.add(CoreWaveletOperationSerializer.deserialize(delta.getOperation(i), context)); } return new TransformedWaveletDelta(author, resultingVersion, applicationTimestamp, operations.build()); } }
@Override public void visitBlipContentOperation(BlipContentOperation blipOp) { mutation.setDocumentOperation(serialize(blipOp.getContentOp())); }
@Override public void submitRequest(ParticipantId loggedInUser, WaveletName waveletName, ProtocolWaveletDelta delta, @Nullable String channelId, SubmitRequestListener listener) { super.submitRequest(loggedInUser, waveletName, delta, channelId, listener); Map<WaveletId, WaveletData> wavelets = waves.get(waveletName.waveId); if (wavelets == null) { wavelets = Maps.newHashMap(); waves.put(waveletName.waveId, wavelets); } WaveletData wavelet = wavelets.get(waveletName.waveletId); if (wavelet == null) { long dummyCreationTime = System.currentTimeMillis(); wavelet = WaveletDataUtil.createEmptyWavelet( waveletName, ParticipantId.ofUnsafe(delta.getAuthor()), HashedVersion.unsigned(0), dummyCreationTime); wavelets.put(waveletName.waveletId, wavelet); } // Add the delta to the history and update the wavelet's version. HashedVersion resultingVersion = updateAndGetVersion(waveletName, delta.getOperationCount()); TransformedWaveletDelta versionedDelta = CoreWaveletOperationSerializer.deserialize(delta, resultingVersion, APP_TIMESTAMP); deltas.put(waveletName, versionedDelta); // Confirm submit success. doSubmitSuccess(waveletName, resultingVersion, APP_TIMESTAMP); // Send an update echoing the submitted delta. Note: the document state is // ignored. waveletUpdate(wavelet, DeltaSequence.of(versionedDelta)); // Send a corresponding update of the index wave. }
provider.getDeltaSignerInfo(signerId, waveletName, (deltaEndVersion == null) ? null : CoreWaveletOperationSerializer.serialize(deltaEndVersion), new DeltaSignerInfoResponseListener() { @Override public void onFailure(FederationError error) {
try { wavelet.requestHistory( CoreWaveletOperationSerializer.deserialize(startVersion), CoreWaveletOperationSerializer.deserialize(endVersion), new Receiver<ByteStringMessage<ProtocolAppliedWaveletDelta>>() {