natas_hw
/
cassandra
mirror of https://github.com/apache/cassandra
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Accord repin: turn pruning back on 

Patch by Alex Petrov; reviewed by Benedict Elliott Smith for CASSANDRA-20114
This commit is contained in:
Alex Petrov 2025-03-12 21:02:21 +01:00 committed by David Capwell
parent 890be9c6e5
commit 289dbb7a05
139 changed files with 4625 additions and 2523 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modules/accord

@ -1 +1 @@
Subproject commit 62b6d6883b689236efb375b6efa7f2350d8d771d
Subproject commit c7379e12bd8f8732004cb77264801fe157af1dbe

9
src/java/org/apache/cassandra/config/AccordSpec.java
View File

@ -23,6 +23,7 @@ import java.util.concurrent.TimeUnit;
import accord.utils.Invariants;
import com.fasterxml.jackson.annotation.JsonIgnore;
import org.apache.cassandra.journal.Params;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.service.consensus.TransactionalMode;
import static org.apache.cassandra.config.AccordSpec.QueueShardModel.THREAD_POOL_PER_SHARD;
@ -192,6 +193,7 @@ public class AccordSpec
public DurationSpec periodicFlushLagBlock = new DurationSpec.IntMillisecondsBound("1500ms");
public DurationSpec.IntMillisecondsBound compactionPeriod = new DurationSpec.IntMillisecondsBound("60000ms");
private volatile long flushCombinedBlockPeriod = Long.MIN_VALUE;
public Version version = Version.DOWNGRADE_SAFE_VERSION;
public void setFlushPeriod(DurationSpec newFlushPeriod)
{
@ -265,12 +267,7 @@ public class AccordSpec
@Override
public int userVersion()
{
/*
* NOTE: when accord journal version gets bumped, expose it via yaml.
* This way operators can force previous version on upgrade, temporarily,
* to allow easier downgrades if something goes wrong.
*/
return 1;
return version.version;
}
}
}

81
src/java/org/apache/cassandra/cql3/conditions/ColumnCondition.java
View File

@ -43,7 +43,7 @@ import org.apache.cassandra.db.rows.Cell;
import org.apache.cassandra.db.rows.ColumnData;
import org.apache.cassandra.db.rows.ComplexColumnData;
import org.apache.cassandra.db.rows.Row;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.ColumnMetadata;
@ -178,14 +178,14 @@ public final class ColumnCondition
return operator.buildCQLString(columnsExpression, values);
}
private interface BoundSerializer<T extends Bound>
public interface BoundSerializer<T extends Bound>
{
default void serialize(T bound, DataOutputPlus out, int version) throws IOException {}
Bound deserialize(DataInputPlus in, int version, ColumnMetadata column, Operator operator, ByteBuffer value) throws IOException;
default long serializedSize(T condition, int version) { return 0; }
default void serialize(T bound, DataOutputPlus out) throws IOException {}
Bound deserialize(DataInputPlus in, ColumnMetadata column, Operator operator, ByteBuffer value) throws IOException;
default long serializedSize(T condition) { return 0; }
}
enum BoundKind
public enum BoundKind
{
Simple(0, SimpleBound.serializer),
ElementOrFieldAccess(1, ElementOrFieldAccessBound.serializer),
@ -193,7 +193,7 @@ public final class ColumnCondition
private final int id;
@SuppressWarnings("rawtypes")
private final BoundSerializer serializer;
public final BoundSerializer serializer;
BoundKind(int id, BoundSerializer<?> serializer)
{
@ -201,7 +201,7 @@ public final class ColumnCondition
this.serializer = serializer;
}
static BoundKind valueOf(int id)
public static BoundKind valueOf(int id)
{
switch (id)
{
@ -215,9 +215,9 @@ public final class ColumnCondition
public static abstract class Bound
{
protected final ColumnMetadata column;
protected final Operator operator;
protected final ByteBuffer value;
public final ColumnMetadata column;
public final Operator operator;
public final ByteBuffer value;
protected Bound(ColumnMetadata column, Operator operator, ByteBuffer value)
{
@ -231,42 +231,39 @@ public final class ColumnCondition
*/
public abstract boolean appliesTo(Row row);
protected abstract BoundKind kind();
public abstract BoundKind kind();
public static final IVersionedSerializer<Bound> serializer = new IVersionedSerializer<>()
{
public static final UnversionedSerializer<Bound> serializer = new UnversionedSerializer<>() {
@Override
@SuppressWarnings("unchecked")
public void serialize(Bound bound, DataOutputPlus out, int version) throws IOException
public void serialize(Bound bound, DataOutputPlus out) throws IOException
{
columnMetadataSerializer.serialize(bound.column, out, version);
columnMetadataSerializer.serialize(bound.column, out);
bound.operator.writeToUnsignedVInt(out);
nullableByteBufferSerializer.serialize(bound.value, out, version);
BoundKind kind = bound.kind();
nullableByteBufferSerializer.serialize(bound.value, out);
ColumnCondition.BoundKind kind = bound.kind();
out.writeUnsignedVInt32(kind.ordinal());
kind.serializer.serialize(bound, out, version);
kind.serializer.serialize(bound, out);
}
@Override
public Bound deserialize(DataInputPlus in, int version) throws IOException
public Bound deserialize(DataInputPlus in) throws IOException
{
ColumnMetadata column = columnMetadataSerializer.deserialize(in, version);
ColumnMetadata column = columnMetadataSerializer.deserialize(in);
Operator operator = Operator.readFromUnsignedVInt(in);
ByteBuffer value = nullableByteBufferSerializer.deserialize(in, version);
BoundKind boundKind = BoundKind.valueOf(in.readUnsignedVInt32());
return boundKind.serializer.deserialize(in, version, column, operator, value);
ByteBuffer value = nullableByteBufferSerializer.deserialize(in);
ColumnCondition.BoundKind boundKind = ColumnCondition.BoundKind.valueOf(in.readUnsignedVInt32());
return boundKind.serializer.deserialize(in, column, operator, value);
}
@Override
@SuppressWarnings("unchecked")
public long serializedSize(Bound bound, int version)
public long serializedSize(Bound bound)
{
BoundKind kind = bound.kind();
return columnMetadataSerializer.serializedSize(bound.column, version)
ColumnCondition.BoundKind kind = bound.kind();
return columnMetadataSerializer.serializedSize(bound.column)
+ bound.operator.sizeAsUnsignedVInt()
+ nullableByteBufferSerializer.serializedSize(bound.value, version)
+ nullableByteBufferSerializer.serializedSize(bound.value)
+ sizeofUnsignedVInt(kind.ordinal())
+ kind.serializer.serializedSize(bound, version);
+ kind.serializer.serializedSize(bound);
}
};
}
@ -276,7 +273,7 @@ public final class ColumnCondition
*/
public static class SimpleBound extends Bound
{
private static final BoundSerializer<SimpleBound> serializer = (in, version, column, operator, value) -> new SimpleBound(column, operator, value);
private static final BoundSerializer<SimpleBound> serializer = (in, column, operator, value) -> new SimpleBound(column, operator, value);
public SimpleBound(ColumnMetadata column, Operator operator, ByteBuffer value)
{
@ -301,7 +298,7 @@ public final class ColumnCondition
}
@Override
protected BoundKind kind()
public BoundKind kind()
{
return BoundKind.Simple;
}
@ -345,22 +342,22 @@ public final class ColumnCondition
private static final BoundSerializer<ElementOrFieldAccessBound> serializer = new BoundSerializer<>()
{
@Override
public void serialize(ElementOrFieldAccessBound bound, DataOutputPlus out, int version) throws IOException
public void serialize(ElementOrFieldAccessBound bound, DataOutputPlus out) throws IOException
{
nullableByteBufferSerializer.serialize(bound.keyOrIndex, out, version);
nullableByteBufferSerializer.serialize(bound.keyOrIndex, out);
}
@Override
public Bound deserialize(DataInputPlus in, int version, ColumnMetadata column, Operator operator, ByteBuffer value) throws IOException
public Bound deserialize(DataInputPlus in, ColumnMetadata column, Operator operator, ByteBuffer value) throws IOException
{
ByteBuffer keyOrIndex = nullableByteBufferSerializer.deserialize(in, version);
ByteBuffer keyOrIndex = nullableByteBufferSerializer.deserialize(in);
return new ElementOrFieldAccessBound(column, keyOrIndex, operator, value);
}
@Override
public long serializedSize(ElementOrFieldAccessBound condition, int version)
public long serializedSize(ElementOrFieldAccessBound condition)
{
return nullableByteBufferSerializer.serializedSize(condition.keyOrIndex, version);
return nullableByteBufferSerializer.serializedSize(condition.keyOrIndex);
}
};
/**
@ -385,7 +382,7 @@ public final class ColumnCondition
}
@Override
protected BoundKind kind()
public BoundKind kind()
{
return BoundKind.ElementOrFieldAccess;
}
@ -428,7 +425,7 @@ public final class ColumnCondition
*/
public static final class MultiCellBound extends Bound
{
private static final BoundSerializer<MultiCellBound> serializer = (in, version, column, operator, value) -> new MultiCellBound(column, operator, value);
private static final BoundSerializer<MultiCellBound> serializer = (in, column, operator, value) -> new MultiCellBound(column, operator, value);
public MultiCellBound(ColumnMetadata column, Operator operator, ByteBuffer value)
{
@ -437,7 +434,7 @@ public final class ColumnCondition
}
@Override
protected BoundKind kind()
public BoundKind kind()
{
return BoundKind.MultiCell;
}

11
src/java/org/apache/cassandra/db/compaction/CompactionIterator.java
View File

@ -95,6 +95,7 @@ import org.apache.cassandra.service.accord.JournalKey;
import org.apache.cassandra.service.accord.api.AccordAgent;
import org.apache.cassandra.service.accord.api.TokenKey;
import org.apache.cassandra.service.accord.journal.AccordTopologyUpdate;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.service.paxos.PaxosRepairHistory;
import org.apache.cassandra.service.paxos.uncommitted.PaxosRows;
import org.apache.cassandra.utils.NoSpamLogger;
@ -845,7 +846,7 @@ public class CompactionIterator extends CompactionInfo.Holder implements Unfilte
// Initialize topology serializer during compaction to avoid deserializing redundant epochs
FlyweightSerializer<AccordTopologyUpdate, Object> topologySerializer;
Object[] highestClustering = null;
final int userVersion;
final Version userVersion;
long lastDescriptor = -1;
int lastOffset = -1;
@ -853,7 +854,7 @@ public class CompactionIterator extends CompactionInfo.Holder implements Unfilte
{
service = (AccordService) serviceSupplier.get();
// TODO: test serialization version logic
userVersion = service.journalConfiguration().userVersion();
userVersion = Version.fromVersion(service.journalConfiguration().userVersion());
this.agent = service.agent();
this.infos = service.getCompactionInfo();
@ -900,7 +901,7 @@ public class CompactionIterator extends CompactionInfo.Holder implements Unfilte
serializer.reserialize(key, builder, out, userVersion);
newVersion.row(highestClustering)
.add("record", out.asNewBuffer())
.add("user_version", userVersion);
.add("user_version", userVersion.version);
}
catch (IOException e)
{
@ -941,7 +942,7 @@ public class CompactionIterator extends CompactionInfo.Holder implements Unfilte
Row.SimpleBuilder rowBuilder = newVersion.row(rows.get(rows.size() - 1).clustering().getBufferArray());
rowBuilder.add("record", commandBuilder.asByteBuffer(userVersion))
.add("user_version", userVersion);
.add("user_version", userVersion.version);
return newVersion.build().unfilteredIterator();
}
@ -987,7 +988,7 @@ public class CompactionIterator extends CompactionInfo.Holder implements Unfilte
try (DataInputBuffer in = new DataInputBuffer(record, false))
{
int userVersion = Int32Type.instance.compose(row.getCell(versionColumn).buffer());
Version userVersion = Version.fromVersion(Int32Type.instance.compose(row.getCell(versionColumn).buffer()));
if (key.type == JournalKey.Type.TOPOLOGY_UPDATE)
topologySerializer.deserialize(key, builder, in, userVersion);
else

35
src/java/org/apache/cassandra/index/accord/RouteIndexFormat.java
View File

@ -43,23 +43,21 @@ import org.apache.cassandra.db.rows.Cell;
import org.apache.cassandra.db.rows.Row;
import org.apache.cassandra.db.rows.Unfiltered;
import org.apache.cassandra.index.accord.IndexDescriptor.IndexComponent;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.LocalVersionedSerializer;
import org.apache.cassandra.io.MessageVersionProvider;
import org.apache.cassandra.io.AsymmetricVersionedSerializer;
import org.apache.cassandra.io.EmbeddedAsymmetricVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.sstable.SSTableFlushObserver;
import org.apache.cassandra.io.util.ChecksumedRandomAccessReader;
import org.apache.cassandra.io.util.ChecksumedSequentialWriter;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.io.util.FileHandle;
import org.apache.cassandra.schema.TableId;
import org.apache.cassandra.serializers.UUIDSerializer;
import org.apache.cassandra.service.accord.AccordJournal;
import org.apache.cassandra.service.accord.AccordJournalTable;
import org.apache.cassandra.service.accord.AccordKeyspace;
import org.apache.cassandra.service.accord.AccordSerializerVersion;
import org.apache.cassandra.service.accord.JournalKey;
import org.apache.cassandra.service.accord.serializers.KeySerializers;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.ByteArrayUtil;
import org.apache.cassandra.utils.Throwables;
@ -71,20 +69,15 @@ public class RouteIndexFormat
{
public static final Supplier<Checksum> CHECKSUM_SUPPLIER = CRC32C::new;
static final LocalVersionedSerializer<Participants<?>> touches = localSerializer(KeySerializers.participants);
private static <T> LocalVersionedSerializer<T> localSerializer(IVersionedSerializer<T> serializer)
static final EmbeddedAsymmetricVersionedSerializer<Participants<?>, Participants<?>, Version> touches = localSerializer(KeySerializers.participants);
private static <T> EmbeddedAsymmetricVersionedSerializer<T, T, Version> localSerializer(UnversionedSerializer<T> serializer)
{
return new LocalVersionedSerializer<>(AccordSerializerVersion.CURRENT, AccordSerializerVersion.serializer, serializer);
return new EmbeddedAsymmetricVersionedSerializer<>(Version.DOWNGRADE_SAFE_VERSION, Version.Serializer.instance, AsymmetricVersionedSerializer.from(serializer));
}
public static ByteBuffer serialize(Participants<?> value) throws IOException
{
int size = Math.toIntExact(touches.serializedSize(value));
try (DataOutputBuffer buffer = new DataOutputBuffer(size))
{
touches.serialize(value, buffer);
return buffer.buffer(true);
}
return touches.serialize(value);
}
static Participants<?> deserializeTouches(ByteBuffer bytes) throws IOException
@ -92,11 +85,7 @@ public class RouteIndexFormat
if (bytes == null || ByteBufferAccessor.instance.isEmpty(bytes))
return null;
try (DataInputBuffer in = new DataInputBuffer(bytes, true))
{
MessageVersionProvider versionProvider = touches.deserializeVersion(in);
return KeySerializers.participants.deserialize(in, versionProvider.messageVersion());
}
return touches.deserialize(bytes);
}
public interface Writer extends SSTableFlushObserver
@ -158,7 +147,7 @@ public class RouteIndexFormat
if (!recordLive)
return null;
ByteBuffer record = recordCell.buffer();
int user_version = Int32Type.instance.compose(user_versionCell.buffer());
Version user_version = Version.fromVersion(Int32Type.instance.compose(user_versionCell.buffer()));
AccordJournal.Builder builder = extract(txnId, record, user_version);
StoreParticipants participants = builder.participants();
if (participants == null)
@ -178,10 +167,10 @@ public class RouteIndexFormat
}
}
public static AccordJournal.Builder extract(TxnId txnId, ByteBuffer record, int user_version)
public static AccordJournal.Builder extract(TxnId txnId, ByteBuffer record, Version userVersion)
{
AccordJournal.Builder builder = new AccordJournal.Builder(txnId, AccordJournal.Load.ALL);
AccordJournalTable.readBuffer(record, builder::deserializeNext, user_version);
AccordJournalTable.readBuffer(record, builder::deserializeNext, userVersion);
return builder;
}

77
src/java/org/apache/cassandra/io/AsymmetricUnversionedSerializer.java Normal file
View File

@ -0,0 +1,77 @@
/*
* 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.apache.cassandra.io;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.ByteBuffer;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.io.util.DataOutputPlus;
public interface AsymmetricUnversionedSerializer<In, Out>
{
void serialize(In t, DataOutputPlus out) throws IOException;
default ByteBuffer serialize(In t) throws IOException
{
int size = Math.toIntExact(serializedSize(t));
try (DataOutputBuffer buffer = new DataOutputBuffer(size))
{
serialize(t, buffer);
ByteBuffer bb = buffer.buffer();
assert size == bb.remaining() : String.format("Expected to write %d but wrote %d", size, bb.remaining());
return bb;
}
}
default ByteBuffer serializeUnchecked(In t)
{
try
{
return serialize(t);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
Out deserialize(DataInputPlus in) throws IOException;
default Out deserialize(ByteBuffer buffer) throws IOException
{
try (DataInputBuffer in = new DataInputBuffer(buffer, true))
{
return deserialize(in);
}
}
default Out deserializeUnchecked(ByteBuffer buffer)
{
try
{
return deserialize(buffer);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
long serializedSize(In t);
}

101
src/java/org/apache/cassandra/io/AsymmetricVersionedSerializer.java Normal file
View File

@ -0,0 +1,101 @@
/*
* 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.apache.cassandra.io;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.ByteBuffer;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.io.util.DataOutputPlus;
public interface AsymmetricVersionedSerializer<In, Out, Version>
{
void serialize(In t, DataOutputPlus out, Version version) throws IOException;
default ByteBuffer serialize(In t, Version version) throws IOException
{
int size = Math.toIntExact(serializedSize(t, version));
try (DataOutputBuffer buffer = new DataOutputBuffer(size))
{
serialize(t, buffer, version);
ByteBuffer bb = buffer.buffer();
assert size == bb.remaining() : String.format("Expected to write %d but wrote %d", size, bb.remaining());
return bb;
}
}
default ByteBuffer serializeUnchecked(In t, Version version)
{
try
{
return serialize(t, version);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
Out deserialize(DataInputPlus in, Version version) throws IOException;
default Out deserialize(ByteBuffer buffer, Version version) throws IOException
{
try (DataInputBuffer in = new DataInputBuffer(buffer, true))
{
return deserialize(in, version);
}
}
default Out deserializeUnchecked(ByteBuffer buffer, Version version)
{
try
{
return deserialize(buffer, version);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
long serializedSize(In t, Version version);
static <In, Out, Version> AsymmetricVersionedSerializer<In, Out, Version> from(AsymmetricUnversionedSerializer<In, Out> delegate)
{
return new AsymmetricVersionedSerializer<>()
{
@Override
public void serialize(In t, DataOutputPlus out, Version version) throws IOException
{
delegate.serialize(t, out);
}
@Override
public Out deserialize(DataInputPlus in, Version version) throws IOException
{
return delegate.deserialize(in);
}
@Override
public long serializedSize(In t, Version version)
{
return delegate.serializedSize(t);
}
};
}
}

84
src/java/org/apache/cassandra/io/EmbeddedAsymmetricVersionedSerializer.java Normal file
View File

@ -0,0 +1,84 @@
/*
* 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.apache.cassandra.io;
import java.io.IOException;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public class EmbeddedAsymmetricVersionedSerializer<In, Out, Version> implements IVersionedAsymmetricSerializer<In, Out>, AsymmetricUnversionedSerializer<In, Out>
{
private final Version version;
private final UnversionedSerializer<Version> versionSerializer;
private final AsymmetricVersionedSerializer<In, Out, Version> delegate;
public EmbeddedAsymmetricVersionedSerializer(Version version,
UnversionedSerializer<Version> versionSerializer,
AsymmetricVersionedSerializer<In, Out, Version> delegate)
{
this.version = version;
this.versionSerializer = versionSerializer;
this.delegate = delegate;
}
@Override
public void serialize(In t, DataOutputPlus out, int msgVersion) throws IOException
{
serialize(t, out);
}
@Override
public void serialize(In t, DataOutputPlus out) throws IOException
{
versionSerializer.serialize(version, out);
delegate.serialize(t, out, version);
}
@Override
public Out deserialize(DataInputPlus in, int msgVersion) throws IOException
{
return deserialize(in);
}
@Override
public Out deserialize(DataInputPlus in) throws IOException
{
Version version = versionSerializer.deserialize(in);
return delegate.deserialize(in, version);
}
public Version deserializeVersion(DataInputPlus in) throws IOException
{
return versionSerializer.deserialize(in);
}
@Override
public long serializedSize(In t, int msgVersion)
{
return serializedSize(t);
}
@Override
public long serializedSize(In t)
{
return versionSerializer.serializedSize(version)
+ delegate.serializedSize(t, version);
}
}

48
src/java/org/apache/cassandra/io/IVersionedAsymmetricSerializer.java
View File

@ -18,8 +18,12 @@
package org.apache.cassandra.io;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.ByteBuffer;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.io.util.DataOutputPlus;
public interface IVersionedAsymmetricSerializer<In, Out>
@ -34,6 +38,30 @@ public interface IVersionedAsymmetricSerializer<In, Out>
*/
void serialize(In t, DataOutputPlus out, int version) throws IOException;
default ByteBuffer serialize(In t, int version) throws IOException
{
int size = Math.toIntExact(serializedSize(t, version));
try (DataOutputBuffer buffer = new DataOutputBuffer(size))
{
serialize(t, buffer, version);
ByteBuffer bb = buffer.buffer();
assert size == bb.remaining() : String.format("Expected to write %d but wrote %d", size, bb.remaining());
return bb;
}
}
default ByteBuffer serializeUnchecked(In t, int version)
{
try
{
return serialize(t, version);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
/**
* Deserialize into the specified DataInputStream instance.
* @param in DataInput from which deserialization needs to happen.
@ -43,6 +71,26 @@ public interface IVersionedAsymmetricSerializer<In, Out>
*/
Out deserialize(DataInputPlus in, int version) throws IOException;
default Out deserialize(ByteBuffer buffer, int version) throws IOException
{
try (DataInputBuffer in = new DataInputBuffer(buffer, true))
{
return deserialize(in, version);
}
}
default Out deserializeUnchecked(ByteBuffer buffer, int version)
{
try
{
return deserialize(buffer, version);
}
catch (IOException e)
{
throw new UncheckedIOException(e);
}
}
/**
* Calculate serialized size of object without actually serializing.
* @param t object to calculate serialized size

28
src/java/org/apache/cassandra/io/IVersionedSerializer.java
View File

@ -17,6 +17,34 @@
*/
package org.apache.cassandra.io;
import java.io.IOException;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public interface IVersionedSerializer<T> extends IVersionedAsymmetricSerializer<T, T>
{
static <T> IVersionedSerializer<T> from(UnversionedSerializer<T> delegate)
{
return new IVersionedSerializer<T>()
{
@Override
public void serialize(T t, DataOutputPlus out, int version) throws IOException
{
delegate.serialize(t, out);
}
@Override
public T deserialize(DataInputPlus in, int version) throws IOException
{
return delegate.deserialize(in);
}
@Override
public long serializedSize(T t, int version)
{
return delegate.serializedSize(t);
}
};
}
}

99
src/java/org/apache/cassandra/io/LocalVersionedSerializer.java
View File

@ -1,99 +0,0 @@
/*
* 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.apache.cassandra.io;
import java.io.IOException;
import java.util.Objects;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
/**
* Serializer that stores the version within the buffer. Normal usage of {@link IVersionedSerializer} is to rely on
* {@link org.apache.cassandra.net.MessagingService#current_version} and messaging version numbers, but that implies
* that a messaging version bump is required if a change is made to this field; for some cases the serializer isn't
* dealing with messages and instead are blobs stored in a table, for these cases it may be better to rely on a field
* specific versioning that gets stored along the data.
*/
public class LocalVersionedSerializer<I>
{
private final MessageVersionProvider currentVersion;
private final IVersionedSerializer<MessageVersionProvider> versionSerializer;
private final IVersionedSerializer<I> serializer;
public <V extends MessageVersionProvider> LocalVersionedSerializer(V currentVersion,
IVersionedSerializer<V> versionSerializer,
IVersionedSerializer<I> serializer)
{
// V is local to the constructor to validate at construction time things are fine, but don't want in the type
// sig of the class as it just gets verbose...
this.currentVersion = Objects.requireNonNull(currentVersion);
this.versionSerializer = (IVersionedSerializer<MessageVersionProvider>) Objects.requireNonNull(versionSerializer);
this.serializer = Objects.requireNonNull(serializer);
}
public MessageVersionProvider deserializeVersion(DataInputPlus in) throws IOException
{
return versionSerializer.deserialize(in, currentVersion.messageVersion());
}
public IVersionedSerializer<I> serializer()
{
return serializer;
}
/**
* Serialize the specified type into the specified DataOutputStream instance.
*
* @param t type that needs to be serialized
* @param out DataOutput into which serialization needs to happen.
* @throws IOException if serialization fails
*/
public void serialize(I t, DataOutputPlus out) throws IOException
{
versionSerializer.serialize(currentVersion, out, currentVersion.messageVersion());
serializer.serialize(t, out, currentVersion.messageVersion());
}
/**
* Deserialize into the specified DataInputStream instance.
*
* @param in DataInput from which deserialization needs to happen.
* @return the type that was deserialized
* @throws IOException if deserialization fails
*/
public I deserialize(DataInputPlus in) throws IOException
{
MessageVersionProvider version = versionSerializer.deserialize(in, currentVersion.messageVersion());
return serializer.deserialize(in, version.messageVersion());
}
/**
* Calculate serialized size of object without actually serializing.
*
* @param t object to calculate serialized size
* @return serialized size of object t
*/
public long serializedSize(I t)
{
long size = versionSerializer.serializedSize(currentVersion, currentVersion.messageVersion());
size += serializer.serializedSize(t, currentVersion.messageVersion());
return size;
}
}

23
src/java/org/apache/cassandra/io/UnversionedSerializer.java Normal file
View File

@ -0,0 +1,23 @@
/*
* 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.apache.cassandra.io;
public interface UnversionedSerializer<T> extends AsymmetricUnversionedSerializer<T, T>
{
}

23
src/java/org/apache/cassandra/io/VersionedSerializer.java Normal file
View File

@ -0,0 +1,23 @@
/*
* 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.apache.cassandra.io;
public interface VersionedSerializer<T, Version> extends AsymmetricVersionedSerializer<T, T, Version>
{
}

18
src/java/org/apache/cassandra/io/util/DataOutputPlus.java
View File

@ -132,11 +132,27 @@ public interface DataOutputPlus extends DataOutput
}
}
private static int numberOfBytes(long value)
{
return (64 + 7 - Long.numberOfLeadingZeros(value)) / 8;
}
/**
* An efficient way to write the type {@code bytes} of a long
*
* @param register - the long value to be written
* @param bytes - the number of bytes the register occupies. Valid values are between 1 and 8 inclusive.
* @throws IOException
*/
default void writeLeastSignificantBytes(long register) throws IOException
{
writeLeastSignificantBytes(register, numberOfBytes(register));
}
/**
* An efficient way to write the type {@code bytes} of a long
*
* @param register - the long value to be written
* @param bytes - the number of bytes the register occupies. Valid values are between 0 and 8 inclusive.
* @throws IOException
*/
default void writeLeastSignificantBytes(long register, int bytes) throws IOException

27
src/java/org/apache/cassandra/net/MessagingService.java
View File

@ -224,23 +224,6 @@ public class MessagingService extends MessagingServiceMBeanImpl implements Messa
VERSION_50(13),
VERSION_51(14);
public static final Version CURRENT;
private static final Logger logger = LoggerFactory.getLogger(Version.class);
static
{
if (DatabaseDescriptor.getStorageCompatibilityMode().isBefore(5))
{
logger.warn("Starting in storage compatibility mode " + DatabaseDescriptor.getStorageCompatibilityMode());
CURRENT = VERSION_40;
}
else
{
CURRENT = VERSION_51;
}
}
public static final Version MIN_ACCORD_VERSION = Version.VERSION_51;
public final int value;
@ -250,6 +233,13 @@ public class MessagingService extends MessagingServiceMBeanImpl implements Messa
this.value = value;
}
public static Version current()
{
// this enum is leveraged in yaml config so can not touch DatabaseDescriptor to figure out
// what the "current" is, so need to leverage MessagingService's field as it uses DatabaseDescriptor
return current;
}
public static List<Version> supportedVersions()
{
List<Version> versions = Lists.newArrayList();
@ -288,7 +278,8 @@ public class MessagingService extends MessagingServiceMBeanImpl implements Messa
// we want to use a modified behavior for the tools and clients - that is, since they are not running a server, they
// should not need to run in a compatibility mode. They should be able to connect to the server regardless whether
// it uses messaving version 4 or 5
public static final int current_version = DatabaseDescriptor.getStorageCompatibilityMode().isBefore(5) ? VERSION_40 : VERSION_51;
public static final Version current = DatabaseDescriptor.getStorageCompatibilityMode().isBefore(5) ? Version.VERSION_40 : Version.VERSION_51;
public static final int current_version = current.value;
static AcceptVersions accept_messaging;
static AcceptVersions accept_streaming;
static

19
src/java/org/apache/cassandra/net/NoPayload.java
View File

@ -18,6 +18,7 @@
package org.apache.cassandra.net;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
@ -50,4 +51,22 @@ public class NoPayload
return 0;
}
};
public static final UnversionedSerializer<NoPayload> unversionedSerializer = new UnversionedSerializer<NoPayload>()
{
public void serialize(NoPayload noPayload, DataOutputPlus out)
{
if (noPayload != NoPayload.noPayload)
throw new IllegalArgumentException();
}
public NoPayload deserialize(DataInputPlus in)
{
return noPayload;
}
public long serializedSize(NoPayload noPayload)
{
return 0;
}
};
}

119
src/java/org/apache/cassandra/net/Verb.java
View File

@ -55,6 +55,8 @@ import org.apache.cassandra.gms.GossipShutdown;
import org.apache.cassandra.gms.GossipShutdownVerbHandler;
import org.apache.cassandra.hints.HintMessage;
import org.apache.cassandra.hints.HintVerbHandler;
import org.apache.cassandra.io.AsymmetricUnversionedSerializer;
import org.apache.cassandra.io.AsymmetricVersionedSerializer;
import org.apache.cassandra.io.IVersionedAsymmetricSerializer;
import org.apache.cassandra.repair.RepairMessageVerbHandler;
import org.apache.cassandra.repair.messages.CleanupMessage;
@ -78,6 +80,7 @@ import org.apache.cassandra.schema.SchemaPushVerbHandler;
import org.apache.cassandra.schema.SchemaVersionVerbHandler;
import org.apache.cassandra.service.EchoVerbHandler;
import org.apache.cassandra.service.SnapshotVerbHandler;
import org.apache.cassandra.service.accord.AccordSerializers;
import org.apache.cassandra.service.accord.AccordService;
import org.apache.cassandra.service.accord.AccordSyncPropagator;
import org.apache.cassandra.service.accord.AccordSyncPropagator.Notification;
@ -104,6 +107,7 @@ import org.apache.cassandra.service.accord.serializers.GetDurableBeforeSerialize
import org.apache.cassandra.service.accord.serializers.ReadDataSerializers;
import org.apache.cassandra.service.accord.serializers.RecoverySerializers;
import org.apache.cassandra.service.accord.serializers.SetDurableSerializers;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.service.consensus.migration.ConsensusKeyMigrationState;
import org.apache.cassandra.service.consensus.migration.ConsensusKeyMigrationState.ConsensusKeyMigrationFinished;
import org.apache.cassandra.service.paxos.Commit;
@ -202,7 +206,7 @@ public enum Verb
PAXOS_PREPARE_RSP (93, P2, writeTimeout, REQUEST_RESPONSE, () -> PrepareResponse.serializer, RESPONSE_HANDLER ),
PAXOS_PREPARE_REQ (33, P2, writeTimeout, MUTATION, () -> Commit.serializer, () -> PrepareVerbHandler.instance, PAXOS_PREPARE_RSP ),
PAXOS_PROPOSE_RSP (94, P2, writeTimeout, REQUEST_RESPONSE, () -> BooleanSerializer.serializer, RESPONSE_HANDLER ),
PAXOS_PROPOSE_RSP (94, P2, writeTimeout, REQUEST_RESPONSE, () -> BooleanSerializer.messagingSerializer, RESPONSE_HANDLER ),
PAXOS_PROPOSE_REQ (34, P2, writeTimeout, MUTATION, () -> Commit.serializer, () -> ProposeVerbHandler.instance, PAXOS_PROPOSE_RSP ),
PAXOS_COMMIT_RSP (95, P2, writeTimeout, REQUEST_RESPONSE, () -> NoPayload.serializer, RESPONSE_HANDLER ),
PAXOS_COMMIT_REQ (35, P2, writeTimeout, MUTATION, () -> Agreed.serializer, () -> PaxosCommit.requestHandler, PAXOS_COMMIT_RSP ),
@ -311,62 +315,63 @@ public enum Verb
DATA_MOVEMENT_EXECUTED_REQ (817, P1, rpcTimeout, MISC, () -> DataMovement.Status.serializer, () -> DataMovements.instance, DATA_MOVEMENT_EXECUTED_RSP ),
// accord
ACCORD_SIMPLE_RSP (119, P2, writeTimeout, IMMEDIATE, () -> EnumSerializer.simpleReply, AccordService::responseHandlerOrNoop ),
ACCORD_PRE_ACCEPT_RSP (120, P2, writeTimeout, IMMEDIATE, () -> PreacceptSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_PRE_ACCEPT_REQ (121, P2, writeTimeout, IMMEDIATE, () -> PreacceptSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_PRE_ACCEPT_RSP ),
ACCORD_ACCEPT_RSP (122, P2, writeTimeout, IMMEDIATE, () -> AcceptSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_ACCEPT_REQ (123, P2, writeTimeout, IMMEDIATE, () -> AcceptSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_ACCEPT_RSP ),
ACCORD_NOT_ACCEPT_REQ (124, P2, writeTimeout, IMMEDIATE, () -> AcceptSerializers.notAccept, AccordService::requestHandlerOrNoop, ACCORD_ACCEPT_RSP ),
ACCORD_READ_RSP (125, P2, readTimeout, IMMEDIATE, () -> ReadDataSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_READ_REQ (126, P2, readTimeout, IMMEDIATE, () -> ReadDataSerializers.readData, AccordService::requestHandlerOrNoop, ACCORD_READ_RSP ),
ACCORD_STABLE_THEN_READ_REQ (127, P2, writeTimeout, IMMEDIATE, () -> ReadDataSerializers.stableThenRead, AccordService::requestHandlerOrNoop, ACCORD_READ_RSP ),
ACCORD_COMMIT_REQ (128, P2, writeTimeout, IMMEDIATE, () -> CommitSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_READ_RSP ),
ACCORD_COMMIT_INVALIDATE_REQ (129, P2, writeTimeout, IMMEDIATE, () -> CommitSerializers.invalidate, AccordService::requestHandlerOrNoop ),
ACCORD_APPLY_RSP (130, P2, writeTimeout, IMMEDIATE, () -> ApplySerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_APPLY_REQ (131, P2, writeTimeout, IMMEDIATE, () -> ApplySerializers.request, AccordService::requestHandlerOrNoop, ACCORD_APPLY_RSP ),
ACCORD_APPLY_AND_WAIT_REQ (132, P2, writeTimeout, IMMEDIATE, () -> ReadDataSerializers.readData, AccordService::requestHandlerOrNoop, ACCORD_READ_RSP),
ACCORD_BEGIN_RECOVER_RSP (133, P2, writeTimeout, IMMEDIATE, () -> RecoverySerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_BEGIN_RECOVER_REQ (134, P2, writeTimeout, IMMEDIATE, () -> RecoverySerializers.request, AccordService::requestHandlerOrNoop, ACCORD_BEGIN_RECOVER_RSP ),
ACCORD_BEGIN_INVALIDATE_RSP (135, P2, writeTimeout, IMMEDIATE, () -> BeginInvalidationSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_BEGIN_INVALIDATE_REQ (136, P2, writeTimeout, IMMEDIATE, () -> BeginInvalidationSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_BEGIN_INVALIDATE_RSP ),
ACCORD_AWAIT_RSP (137, P2, writeTimeout, IMMEDIATE, () -> AwaitSerializers.syncReply, AccordService::responseHandlerOrNoop ),
ACCORD_AWAIT_REQ (138, P2, writeTimeout, IMMEDIATE, () -> AwaitSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_AWAIT_RSP ),
ACCORD_AWAIT_ASYNC_RSP_REQ (139, P2, writeTimeout, IMMEDIATE, () -> AwaitSerializers.asyncReply, AccordService::requestHandlerOrNoop ),
ACCORD_WAIT_UNTIL_APPLIED_REQ (140, P2, writeTimeout, IMMEDIATE, () -> ReadDataSerializers.waitUntilApplied, AccordService::requestHandlerOrNoop, ACCORD_READ_RSP ),
ACCORD_RECOVER_AWAIT_RSP (141, P2, writeTimeout, IMMEDIATE, () -> AwaitSerializers.recoverReply, AccordService::responseHandlerOrNoop ),
ACCORD_RECOVER_AWAIT_REQ (142, P2, writeTimeout, IMMEDIATE, () -> AwaitSerializers.recoverRequest, AccordService::requestHandlerOrNoop, ACCORD_RECOVER_AWAIT_RSP),
ACCORD_INFORM_DURABLE_REQ (143, P2, writeTimeout, IMMEDIATE, () -> InformDurableSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_SIMPLE_RSP ),
ACCORD_CHECK_STATUS_RSP (144, P2, writeTimeout, IMMEDIATE, () -> CheckStatusSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_CHECK_STATUS_REQ (145, P2, writeTimeout, IMMEDIATE, () -> CheckStatusSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_CHECK_STATUS_RSP ),
ACCORD_FETCH_DATA_RSP (146, P2, writeTimeout, IMMEDIATE, () -> FetchSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_FETCH_DATA_REQ (147, P2, writeTimeout, IMMEDIATE, () -> FetchSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_FETCH_DATA_RSP ),
ACCORD_GET_EPHMRL_READ_DEPS_RSP (148, P2, readTimeout, IMMEDIATE, () -> GetEphmrlReadDepsSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_GET_EPHMRL_READ_DEPS_REQ (149, P2, readTimeout, IMMEDIATE, () -> GetEphmrlReadDepsSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_GET_EPHMRL_READ_DEPS_RSP),
ACCORD_GET_LATEST_DEPS_RSP (150, P2, readTimeout, IMMEDIATE, () -> LatestDepsSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_GET_LATEST_DEPS_REQ (151, P2, readTimeout, IMMEDIATE, () -> LatestDepsSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_GET_LATEST_DEPS_RSP),
ACCORD_GET_MAX_CONFLICT_RSP (152, P2, readTimeout, IMMEDIATE, () -> GetMaxConflictSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_GET_MAX_CONFLICT_REQ (153, P2, readTimeout, IMMEDIATE, () -> GetMaxConflictSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_GET_MAX_CONFLICT_RSP),
ACCORD_GET_DURABLE_BEFORE_RSP (154, P2, readTimeout, IMMEDIATE, () -> GetDurableBeforeSerializers.reply, AccordService::responseHandlerOrNoop ),
ACCORD_GET_DURABLE_BEFORE_REQ (155, P2, readTimeout, IMMEDIATE, () -> GetDurableBeforeSerializers.request, AccordService::requestHandlerOrNoop, ACCORD_GET_DURABLE_BEFORE_RSP ),
ACCORD_SET_SHARD_DURABLE_REQ (156, P2, rpcTimeout, MISC, () -> SetDurableSerializers.shardDurable, AccordService::requestHandlerOrNoop, ACCORD_SIMPLE_RSP ),
ACCORD_SET_GLOBALLY_DURABLE_REQ (157, P2, rpcTimeout, MISC, () -> SetDurableSerializers.globallyDurable,AccordService::requestHandlerOrNoop, ACCORD_SIMPLE_RSP ),
ACCORD_SIMPLE_RSP (119, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(EnumSerializer.simpleReply), AccordService::responseHandlerOrNoop ),
ACCORD_PRE_ACCEPT_RSP (120, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(PreacceptSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_PRE_ACCEPT_REQ (121, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(PreacceptSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_PRE_ACCEPT_RSP ),
ACCORD_ACCEPT_RSP (122, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AcceptSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_ACCEPT_REQ (123, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AcceptSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_ACCEPT_RSP ),
ACCORD_NOT_ACCEPT_REQ (124, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AcceptSerializers.notAccept), AccordService::requestHandlerOrNoop, ACCORD_ACCEPT_RSP ),
ACCORD_READ_RSP (125, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(ReadDataSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_READ_REQ (126, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(ReadDataSerializers.readData), AccordService::requestHandlerOrNoop, ACCORD_READ_RSP ),
ACCORD_STABLE_THEN_READ_REQ (127, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(ReadDataSerializers.stableThenRead), AccordService::requestHandlerOrNoop, ACCORD_READ_RSP ),
ACCORD_COMMIT_REQ (128, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(CommitSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_READ_RSP ),
ACCORD_COMMIT_INVALIDATE_REQ (129, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(CommitSerializers.invalidate), AccordService::requestHandlerOrNoop ),
ACCORD_APPLY_RSP (130, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(ApplySerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_APPLY_REQ (131, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(ApplySerializers.request), AccordService::requestHandlerOrNoop, ACCORD_APPLY_RSP ),
ACCORD_APPLY_AND_WAIT_REQ (132, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(ReadDataSerializers.readData), AccordService::requestHandlerOrNoop, ACCORD_READ_RSP),
ACCORD_BEGIN_RECOVER_RSP (133, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(RecoverySerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_BEGIN_RECOVER_REQ (134, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(RecoverySerializers.request), AccordService::requestHandlerOrNoop, ACCORD_BEGIN_RECOVER_RSP ),
ACCORD_BEGIN_INVALIDATE_RSP (135, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(BeginInvalidationSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_BEGIN_INVALIDATE_REQ (136, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(BeginInvalidationSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_BEGIN_INVALIDATE_RSP ),
ACCORD_AWAIT_RSP (137, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AwaitSerializers.syncReply), AccordService::responseHandlerOrNoop ),
ACCORD_AWAIT_REQ (138, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AwaitSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_AWAIT_RSP ),
ACCORD_AWAIT_ASYNC_RSP_REQ (139, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AwaitSerializers.asyncReply), AccordService::requestHandlerOrNoop ),
ACCORD_WAIT_UNTIL_APPLIED_REQ (140, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(ReadDataSerializers.waitUntilApplied), AccordService::requestHandlerOrNoop, ACCORD_READ_RSP ),
ACCORD_RECOVER_AWAIT_RSP (141, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AwaitSerializers.recoverReply), AccordService::responseHandlerOrNoop ),
ACCORD_RECOVER_AWAIT_REQ (142, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AwaitSerializers.recoverRequest), AccordService::requestHandlerOrNoop, ACCORD_RECOVER_AWAIT_RSP),
ACCORD_INFORM_DURABLE_REQ (143, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(InformDurableSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_SIMPLE_RSP ),
ACCORD_CHECK_STATUS_RSP (144, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(CheckStatusSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_CHECK_STATUS_REQ (145, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(CheckStatusSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_CHECK_STATUS_RSP ),
ACCORD_FETCH_DATA_RSP (146, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(FetchSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_FETCH_DATA_REQ (147, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(FetchSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_FETCH_DATA_RSP ),
ACCORD_GET_EPHMRL_READ_DEPS_RSP (148, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(GetEphmrlReadDepsSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_GET_EPHMRL_READ_DEPS_REQ (149, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(GetEphmrlReadDepsSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_GET_EPHMRL_READ_DEPS_RSP),
ACCORD_GET_LATEST_DEPS_RSP (150, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(LatestDepsSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_GET_LATEST_DEPS_REQ (151, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(LatestDepsSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_GET_LATEST_DEPS_RSP),
ACCORD_GET_MAX_CONFLICT_RSP (152, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(GetMaxConflictSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_GET_MAX_CONFLICT_REQ (153, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(GetMaxConflictSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_GET_MAX_CONFLICT_RSP),
ACCORD_GET_DURABLE_BEFORE_RSP (154, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(GetDurableBeforeSerializers.reply), AccordService::responseHandlerOrNoop ),
ACCORD_GET_DURABLE_BEFORE_REQ (155, P2, readTimeout, IMMEDIATE, () -> accordEmbedded(GetDurableBeforeSerializers.request), AccordService::requestHandlerOrNoop, ACCORD_GET_DURABLE_BEFORE_RSP ),
ACCORD_SET_SHARD_DURABLE_REQ (156, P2, rpcTimeout, MISC, () -> accordEmbedded(SetDurableSerializers.shardDurable), AccordService::requestHandlerOrNoop, ACCORD_SIMPLE_RSP ),
ACCORD_SET_GLOBALLY_DURABLE_REQ (157, P2, rpcTimeout, MISC, () -> accordEmbedded(SetDurableSerializers.globallyDurable),AccordService::requestHandlerOrNoop, ACCORD_SIMPLE_RSP ),
ACCORD_SYNC_NOTIFY_RSP (158, P2, writeTimeout, MISC, () -> EnumSerializer.simpleReply, RESPONSE_HANDLER),
ACCORD_SYNC_NOTIFY_REQ (159, P2, writeTimeout, MISC, () -> Notification.serializer, () -> AccordSyncPropagator.verbHandler, ACCORD_SYNC_NOTIFY_RSP ),
ACCORD_SYNC_NOTIFY_RSP (158, P2, writeTimeout, MISC, () -> accordEmbedded(EnumSerializer.simpleReply), RESPONSE_HANDLER),
ACCORD_SYNC_NOTIFY_REQ (159, P2, writeTimeout, MISC, () -> accordEmbedded(Notification.serializer), () -> AccordSyncPropagator.verbHandler, ACCORD_SYNC_NOTIFY_RSP ),
CONSENSUS_KEY_MIGRATION (160, P1, writeTimeout, MISC, () -> ConsensusKeyMigrationFinished.serializer,() -> ConsensusKeyMigrationState.consensusKeyMigrationFinishedHandler),
CONSENSUS_KEY_MIGRATION (160, P1, writeTimeout, MISC, () -> accordEmbedded(ConsensusKeyMigrationFinished.serializer),() -> ConsensusKeyMigrationState.consensusKeyMigrationFinishedHandler),
ACCORD_INTEROP_READ_RSP (161, P2, writeTimeout, IMMEDIATE, () -> AccordInteropRead.replySerializer, AccordService::responseHandlerOrNoop),
ACCORD_INTEROP_READ_REQ (162, P2, writeTimeout, IMMEDIATE, () -> AccordInteropRead.requestSerializer, AccordService::requestHandlerOrNoop, ACCORD_INTEROP_READ_RSP),
ACCORD_INTEROP_STABLE_THEN_READ_REQ(163, P2, writeTimeout, IMMEDIATE, () -> AccordInteropStableThenRead.requestSerializer, AccordService::requestHandlerOrNoop, ACCORD_INTEROP_READ_RSP),
ACCORD_INTEROP_READ_REPAIR_RSP (164, P2, writeTimeout, IMMEDIATE, () -> AccordInteropReadRepair.replySerializer, AccordService::responseHandlerOrNoop),
ACCORD_INTEROP_READ_REPAIR_REQ (165, P2, writeTimeout, IMMEDIATE, () -> AccordInteropReadRepair.requestSerializer, AccordService::requestHandlerOrNoop, ACCORD_INTEROP_READ_REPAIR_RSP),
ACCORD_INTEROP_APPLY_REQ (166, P2, writeTimeout, IMMEDIATE, () -> AccordInteropApply.serializer, AccordService::requestHandlerOrNoop, ACCORD_APPLY_RSP),
ACCORD_FETCH_WATERMARKS_RSP (167, P0, shortTimeout, FETCH_METADATA, () -> WatermarkCollector.serializer, RESPONSE_HANDLER),
ACCORD_INTEROP_READ_RSP (161, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AccordInteropRead.replySerializer), AccordService::responseHandlerOrNoop),
ACCORD_INTEROP_READ_REQ (162, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AccordInteropRead.requestSerializer), AccordService::requestHandlerOrNoop, ACCORD_INTEROP_READ_RSP),
ACCORD_INTEROP_STABLE_THEN_READ_REQ(163, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AccordInteropStableThenRead.requestSerializer), AccordService::requestHandlerOrNoop, ACCORD_INTEROP_READ_RSP),
ACCORD_INTEROP_READ_REPAIR_RSP (164, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AccordInteropReadRepair.replySerializer), AccordService::responseHandlerOrNoop),
ACCORD_INTEROP_READ_REPAIR_REQ (165, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AccordInteropReadRepair.requestSerializer), AccordService::requestHandlerOrNoop, ACCORD_INTEROP_READ_REPAIR_RSP),
ACCORD_INTEROP_APPLY_REQ (166, P2, writeTimeout, IMMEDIATE, () -> accordEmbedded(AccordInteropApply.serializer), AccordService::requestHandlerOrNoop, ACCORD_APPLY_RSP),
ACCORD_FETCH_WATERMARKS_RSP (167, P0, shortTimeout, FETCH_METADATA, () -> accordEmbedded(WatermarkCollector.serializer), RESPONSE_HANDLER),
// NoPayload can not be prefixed with accord version as it is special cased in C* messaging
ACCORD_FETCH_WATERMARKS_REQ (168, P0, shortTimeout, FETCH_METADATA, () -> NoPayload.serializer, AccordService::watermarkHandlerOrNoop, ACCORD_FETCH_WATERMARKS_RSP),
ACCORD_FETCH_TOPOLOGY_RSP (169, P0, shortTimeout, FETCH_METADATA, () -> FetchTopologies.responseSerializer, RESPONSE_HANDLER),
ACCORD_FETCH_TOPOLOGY_REQ (170, P0, shortTimeout, FETCH_METADATA, () -> FetchTopologies.serializer, () -> FetchTopologies.handler, ACCORD_FETCH_TOPOLOGY_RSP),
ACCORD_FETCH_TOPOLOGY_RSP (169, P0, shortTimeout, FETCH_METADATA, () -> accordEmbedded(FetchTopologies.responseSerializer), RESPONSE_HANDLER),
ACCORD_FETCH_TOPOLOGY_REQ (170, P0, shortTimeout, FETCH_METADATA, () -> accordEmbedded(FetchTopologies.serializer), () -> FetchTopologies.handler, ACCORD_FETCH_TOPOLOGY_RSP),
// generic failure response
FAILURE_RSP (99, P0, noTimeout, REQUEST_RESPONSE, () -> RequestFailure.serializer, RESPONSE_HANDLER ),
@ -632,6 +637,16 @@ public enum Verb
{
return CUSTOM_VERB_START - id;
}
private static <A, B> IVersionedAsymmetricSerializer<A, B> accordEmbedded(AsymmetricVersionedSerializer<A, B, Version> delegate)
{
return AccordSerializers.embedded(Version.CLUSTER_SAFE_VERSION, delegate);
}
private static <A, B> IVersionedAsymmetricSerializer<A, B> accordEmbedded(AsymmetricUnversionedSerializer<A, B> delegate)
{
return accordEmbedded(AsymmetricVersionedSerializer.from(delegate));
}
}
@SuppressWarnings("unused")

11
src/java/org/apache/cassandra/service/accord/AbstractAccordSegmentCompactor.java
View File

@ -41,6 +41,7 @@ import org.apache.cassandra.service.accord.AccordJournalValueSerializers.Flyweig
import org.apache.cassandra.utils.NoSpamLogger;
import static java.util.concurrent.TimeUnit.MINUTES;
import org.apache.cassandra.service.accord.serializers.Version;
/**
* Segment compactor: takes static segments and compacts them into a single SSTable.
@ -50,10 +51,10 @@ public abstract class AbstractAccordSegmentCompactor<V> implements SegmentCompac
protected static final Logger logger = LoggerFactory.getLogger(AbstractAccordSegmentCompactor.class);
private static final NoSpamLogger.NoSpamLogStatement unknownTable = NoSpamLogger.getStatement(logger, "Unknown (probably dropped) TableId {} reading {}; skipping record", 1L, MINUTES);
protected final int userVersion;
protected final Version userVersion;
protected final ColumnFamilyStore cfs;
public AbstractAccordSegmentCompactor(int userVersion, ColumnFamilyStore cfs)
public AbstractAccordSegmentCompactor(Version userVersion, ColumnFamilyStore cfs)
{
this.userVersion = userVersion;
this.cfs = cfs;
@ -115,6 +116,8 @@ public abstract class AbstractAccordSegmentCompactor<V> implements SegmentCompac
firstOffset = lastOffset = -1;
}
Version realVersion = Version.fromVersion(reader.descriptor.userVersion);
boolean advanced;
do
{
@ -131,7 +134,7 @@ public abstract class AbstractAccordSegmentCompactor<V> implements SegmentCompac
reader.offset() < lastOffset,
"Offsets were accessed out of order: %d was accessed after %s", reader.offset(), lastOffset);
}
serializer.deserialize(key, builder, in, reader.descriptor.userVersion);
serializer.deserialize(key, builder, in, realVersion);
lastDescriptor = reader.descriptor.timestamp;
lastOffset = reader.offset();
if (firstDescriptor == -1)
@ -196,7 +199,7 @@ public abstract class AbstractAccordSegmentCompactor<V> implements SegmentCompac
serializer.reserialize(key, builder, out, userVersion);
partitionBuilder.row(descriptor, offset)
.add("record", out.asNewBuffer())
.add("user_version", userVersion);
.add("user_version", userVersion.version);
}
writer().append(partitionBuilder.build().unfilteredIterator());
}

6
src/java/org/apache/cassandra/service/accord/AccordCache.java
View File

@ -62,13 +62,13 @@ import org.apache.cassandra.metrics.AccordCacheMetrics;
import org.apache.cassandra.metrics.CacheAccessMetrics;
import org.apache.cassandra.service.accord.AccordCacheEntry.Status;
import org.apache.cassandra.service.accord.events.CacheEvents;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.NoSpamLogger;
import org.apache.cassandra.utils.NoSpamLogger.NoSpamLogStatement;
import org.apache.cassandra.utils.ObjectSizes;
import static accord.utils.Invariants.illegalState;
import static accord.utils.Invariants.require;
import static org.apache.cassandra.net.MessagingService.current_version;
import static org.apache.cassandra.service.accord.AccordCacheEntry.Status.EVICTED;
import static org.apache.cassandra.service.accord.AccordCacheEntry.Status.LOADED;
import static org.apache.cassandra.service.accord.AccordCacheEntry.Status.MODIFIED;
@ -1212,7 +1212,7 @@ public class AccordCache implements CacheSize
try
{
return AccordJournal.asSerializedChange(null, value, current_version);
return AccordJournal.asSerializedChange(null, value, Version.LATEST);
}
catch (IOException e)
{
@ -1229,7 +1229,7 @@ public class AccordCache implements CacheSize
buffer.mark();
try (DataInputBuffer buf = new DataInputBuffer(buffer, false))
{
builder.deserializeNext(buf, current_version);
builder.deserializeNext(buf, Version.LATEST);
return builder.construct(commandStore.unsafeGetRedundantBefore());
}
catch (UnknownTableException e)

6
src/java/org/apache/cassandra/service/accord/AccordFastPath.java
View File

@ -252,7 +252,7 @@ public class AccordFastPath implements MetadataValue<AccordFastPath>
out.writeInt(map.size());
for (Map.Entry<Node.Id, NodeInfo> entry : map.entrySet())
{
TopologySerializers.nodeId.serialize(entry.getKey(), out, version);
TopologySerializers.nodeId.serialize(entry.getKey(), out);
NodeInfo.serializer.serialize(entry.getValue(), out, version);
}
}
@ -271,7 +271,7 @@ public class AccordFastPath implements MetadataValue<AccordFastPath>
ImmutableMap.Builder<Node.Id, NodeInfo> builder = ImmutableMap.builder();
for (int i=0; i<size; i++)
builder.put(TopologySerializers.nodeId.deserialize(in, version),
builder.put(TopologySerializers.nodeId.deserialize(in),
NodeInfo.serializer.deserialize(in, version));
return builder.build();
}
@ -287,7 +287,7 @@ public class AccordFastPath implements MetadataValue<AccordFastPath>
long size = TypeSizes.INT_SIZE;
for (Map.Entry<Node.Id, NodeInfo> entry : map.entrySet())
{
size += TopologySerializers.nodeId.serializedSize(entry.getKey(), version);
size += TopologySerializers.nodeId.serializedSize(entry.getKey());
size += NodeInfo.serializer.serializedSize(entry.getValue(), version);
}
return size;

71
src/java/org/apache/cassandra/service/accord/AccordFetchCoordinator.java
View File

@ -50,7 +50,8 @@ import accord.utils.Invariants;
import accord.utils.async.AsyncChain;
import accord.utils.async.AsyncChains;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.VersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.locator.InetAddressAndPort;
@ -58,7 +59,9 @@ import org.apache.cassandra.locator.RangesAtEndpoint;
import org.apache.cassandra.schema.TableId;
import org.apache.cassandra.schema.TableMetadata;
import org.apache.cassandra.service.accord.serializers.CommandSerializers;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.KeySerializers;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.streaming.PreviewKind;
import org.apache.cassandra.streaming.StreamCoordinator;
import org.apache.cassandra.streaming.StreamManager;
@ -92,47 +95,47 @@ public class AccordFetchCoordinator extends AbstractFetchCoordinator implements
this.hasData = hasData;
}
static final IVersionedSerializer<SessionInfo> serializer = new IVersionedSerializer<>()
static final UnversionedSerializer<SessionInfo> serializer = new UnversionedSerializer<>()
{
public void serialize(SessionInfo info, DataOutputPlus out, int version) throws IOException
public void serialize(SessionInfo info, DataOutputPlus out) throws IOException
{
TimeUUID.Serializer.instance.serialize(info.planId, out, version);
TimeUUID.Serializer.instance.serialize(info.planId, out);
out.writeBoolean(info.hasData);
}
public SessionInfo deserialize(DataInputPlus in, int version) throws IOException
public SessionInfo deserialize(DataInputPlus in) throws IOException
{
return new SessionInfo(TimeUUID.Serializer.instance.deserialize(in, version), in.readBoolean());
return new SessionInfo(TimeUUID.Serializer.instance.deserialize(in), in.readBoolean());
}
public long serializedSize(SessionInfo info, int version)
public long serializedSize(SessionInfo info)
{
return TimeUUID.Serializer.instance.serializedSize(info.planId, version) + TypeSizes.BOOL_SIZE;
return TimeUUID.Serializer.instance.serializedSize(info.planId) + TypeSizes.BOOL_SIZE;
}
};
}
public static final IVersionedSerializer<StreamData> serializer = new IVersionedSerializer<>()
public static final UnversionedSerializer<StreamData> serializer = new UnversionedSerializer<>()
{
@Override
public void serialize(StreamData data, DataOutputPlus out, int version) throws IOException
public void serialize(StreamData data, DataOutputPlus out) throws IOException
{
serializeMap(data.streams, out, version, TokenRange.serializer, SessionInfo.serializer);
serializeMap(data.streams, out, TokenRange.serializer, SessionInfo.serializer);
}
@Override
public StreamData deserialize(DataInputPlus in, int version) throws IOException
public StreamData deserialize(DataInputPlus in) throws IOException
{
return new StreamData(ImmutableMap.copyOf(deserializeMap(in, version,
return new StreamData(ImmutableMap.copyOf(deserializeMap(in,
TokenRange.serializer,
SessionInfo.serializer)));
}
@Override
public long serializedSize(StreamData data, int version)
public long serializedSize(StreamData data)
{
return serializedMapSize(data.streams, version, TokenRange.serializer, SessionInfo.serializer);
return serializedMapSize(data.streams, TokenRange.serializer, SessionInfo.serializer);
}
};
@ -214,24 +217,24 @@ public class AccordFetchCoordinator extends AbstractFetchCoordinator implements
public static final IVersionedSerializer<StreamingRead> serializer = new IVersionedSerializer<StreamingRead>()
{
@Override
public void serialize(StreamingRead read, DataOutputPlus out, int version) throws IOException
public void serialize(StreamingRead read, DataOutputPlus out, Version version) throws IOException
{
InetAddressAndPort.Serializer.inetAddressAndPortSerializer.serialize(read.to, out, version);
KeySerializers.ranges.serialize(read.ranges, out, version);
InetAddressAndPort.Serializer.inetAddressAndPortSerializer.serialize(read.to, out, version.messageVersion());
KeySerializers.ranges.serialize(read.ranges, out);
}
@Override
public StreamingRead deserialize(DataInputPlus in, int version) throws IOException
public StreamingRead deserialize(DataInputPlus in, Version version) throws IOException
{
return new StreamingRead(InetAddressAndPort.Serializer.inetAddressAndPortSerializer.deserialize(in, version),
KeySerializers.ranges.deserialize(in, version));
return new StreamingRead(InetAddressAndPort.Serializer.inetAddressAndPortSerializer.deserialize(in, version.messageVersion()),
KeySerializers.ranges.deserialize(in));
}
@Override
public long serializedSize(StreamingRead read, int version)
public long serializedSize(StreamingRead read, Version version)
{
return InetAddressAndPort.Serializer.inetAddressAndPortSerializer.serializedSize(read.to, version)
+ KeySerializers.ranges.serializedSize(read.ranges, version);
return InetAddressAndPort.Serializer.inetAddressAndPortSerializer.serializedSize(read.to, version.messageVersion())
+ KeySerializers.ranges.serializedSize(read.ranges);
}
};
@ -302,47 +305,47 @@ public class AccordFetchCoordinator extends AbstractFetchCoordinator implements
public static class StreamingTxn
{
private static final IVersionedSerializer<Read> read = new CastingSerializer<>(StreamingRead.class,
StreamingRead.serializer);
private static final VersionedSerializer<Read, Version> read = CastingSerializer.create(StreamingRead.class,
StreamingRead.serializer);
private static final IVersionedSerializer<Query> query = new IVersionedSerializer<>()
private static final UnversionedSerializer<Query> query = new UnversionedSerializer<>()
{
@Override
public void serialize(Query t, DataOutputPlus out, int version)
public void serialize(Query t, DataOutputPlus out)
{
Invariants.requireArgument(t == noopQuery);
}
@Override
public Query deserialize(DataInputPlus in, int version)
public Query deserialize(DataInputPlus in)
{
return noopQuery;
}
@Override
public long serializedSize(Query t, int version)
public long serializedSize(Query t)
{
Invariants.requireArgument(t == noopQuery);
return 0;
}
};
private static final IVersionedSerializer<Update> update = new IVersionedSerializer<>()
private static final IVersionedSerializer<Update> update = new IVersionedSerializer<Update>()
{
@Override
public void serialize(Update t, DataOutputPlus out, int version)
public void serialize(Update t, DataOutputPlus out, Version version)
{
Invariants.requireArgument(t == null);
}
@Override
public Update deserialize(DataInputPlus in, int version)
public Update deserialize(DataInputPlus in, Version version)
{
return null;
}
@Override
public long serializedSize(Update t, int version)
public long serializedSize(Update t, Version version)
{
Invariants.requireArgument(t == null);
return 0;

63
src/java/org/apache/cassandra/service/accord/AccordJournal.java
View File

@ -75,6 +75,7 @@ import org.apache.cassandra.service.accord.serializers.CommandSerializers;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
import org.apache.cassandra.service.accord.serializers.DepsSerializers;
import org.apache.cassandra.service.accord.serializers.ResultSerializers;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.service.accord.serializers.WaitingOnSerializer;
import org.apache.cassandra.utils.CloseableIterator;
import org.apache.cassandra.utils.ExecutorUtils;
@ -123,6 +124,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
public AccordJournal(Params params, AccordAgent agent, File directory, ColumnFamilyStore cfs)
{
this.agent = agent;
Version userVersion = Version.fromVersion(params.userVersion());
this.journal = new Journal<>("AccordJournal", directory, params, JournalKey.SUPPORT,
// In Accord, we are using streaming serialization, i.e. Reader/Writer interfaces instead of materializing objects
new ValueSerializer<>()
@ -139,14 +141,14 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
throw new UnsupportedOperationException();
}
},
compactor(cfs, params));
this.journalTable = new AccordJournalTable<>(journal, JournalKey.SUPPORT, cfs, params.userVersion());
compactor(cfs, userVersion));
this.journalTable = new AccordJournalTable<>(journal, JournalKey.SUPPORT, cfs, userVersion);
this.params = params;
}
protected SegmentCompactor<JournalKey, Object> compactor(ColumnFamilyStore cfs, Params params)
protected SegmentCompactor<JournalKey, Object> compactor(ColumnFamilyStore cfs, Version userVersion)
{
return new AccordSegmentCompactor<>(params.userVersion(), cfs) {
return new AccordSegmentCompactor<>(userVersion, cfs) {
@Nullable
@Override
public Collection<StaticSegment<JournalKey, Object>> compact(Collection<StaticSegment<JournalKey, Object>> staticSegments)
@ -395,7 +397,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
private <T> RecordPointer appendInternal(JournalKey key, T write)
{
AccordJournalValueSerializers.FlyweightSerializer<T, ?> serializer = (AccordJournalValueSerializers.FlyweightSerializer<T, ?>) key.type.serializer;
return journal.asyncWrite(key, (out, userVersion) -> serializer.serialize(key, write, out, userVersion));
return journal.asyncWrite(key, (out, userVersion) -> serializer.serialize(key, write, out, Version.fromVersion(userVersion)));
}
@VisibleForTesting
@ -473,7 +475,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
}
}
public static @Nullable ByteBuffer asSerializedChange(Command before, Command after, int userVersion) throws IOException
public static @Nullable ByteBuffer asSerializedChange(Command before, Command after, Version userVersion) throws IOException
{
try (DataOutputBuffer out = new DataOutputBuffer())
{
@ -525,11 +527,16 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
@Override
public void write(DataOutputPlus out, int userVersion) throws IOException
{
write(out, Version.fromVersion(userVersion));
}
public void write(DataOutputPlus out, Version userVersion) throws IOException
{
serialize(after, flags, out, userVersion);
}
private static void serialize(Command command, int flags, DataOutputPlus out, int userVersion) throws IOException
private static void serialize(Command command, int flags, DataOutputPlus out, Version userVersion) throws IOException
{
Invariants.require(flags != 0);
out.writeInt(flags);
@ -562,10 +569,10 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
out.writeByte(command.durability().ordinal());
break;
case ACCEPTED:
CommandSerializers.ballot.serialize(command.acceptedOrCommitted(), out, userVersion);
CommandSerializers.ballot.serialize(command.acceptedOrCommitted(), out);
break;
case PROMISED:
CommandSerializers.ballot.serialize(command.promised(), out, userVersion);
CommandSerializers.ballot.serialize(command.promised(), out);
break;
case PARTICIPANTS:
CommandSerializers.participants.serialize(command.participants(), out, userVersion);
@ -574,7 +581,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
CommandSerializers.partialTxn.serialize(command.partialTxn(), out, userVersion);
break;
case PARTIAL_DEPS:
DepsSerializers.partialDeps.serialize(command.partialDeps(), out, userVersion);
DepsSerializers.partialDeps.serialize(command.partialDeps(), out);
break;
case WAITING_ON:
Command.WaitingOn waitingOn = command.waitingOn();
@ -584,7 +591,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
CommandSerializers.writes.serialize(command.writes(), out, userVersion);
break;
case RESULT:
ResultSerializers.result.serialize(command.result(), out, userVersion);
ResultSerializers.result.serialize(command.result(), out);
break;
case CLEANUP:
throw new IllegalStateException();
@ -627,7 +634,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
{
super(txnId, load);
}
public ByteBuffer asByteBuffer(int userVersion) throws IOException
public ByteBuffer asByteBuffer(Version userVersion) throws IOException
{
try (DataOutputBuffer out = new DataOutputBuffer())
{
@ -636,7 +643,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
}
}
public void serialize(DataOutputPlus out, int userVersion) throws IOException
public void serialize(DataOutputPlus out, Version userVersion) throws IOException
{
Invariants.require(mask == 0);
Invariants.require(flags != 0);
@ -645,7 +652,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
serialize(flags, out, userVersion);
}
private void serialize(int flags, DataOutputPlus out, int userVersion) throws IOException
private void serialize(int flags, DataOutputPlus out, Version userVersion) throws IOException
{
Invariants.require(flags != 0);
out.writeInt(flags);
@ -682,11 +689,11 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
break;
case ACCEPTED:
Invariants.require(acceptedOrCommitted != null);
CommandSerializers.ballot.serialize(acceptedOrCommitted, out, userVersion);
CommandSerializers.ballot.serialize(acceptedOrCommitted, out);
break;
case PROMISED:
Invariants.require(promised != null);
CommandSerializers.ballot.serialize(promised, out, userVersion);
CommandSerializers.ballot.serialize(promised, out);
break;
case PARTICIPANTS:
Invariants.require(participants != null);
@ -698,11 +705,11 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
break;
case PARTIAL_DEPS:
Invariants.require(partialDeps != null);
DepsSerializers.partialDeps.serialize(partialDeps, out, userVersion);
DepsSerializers.partialDeps.serialize(partialDeps, out);
break;
case WAITING_ON:
Invariants.require(waitingOn != null);
((WaitingOnSerializer.Provider)waitingOn).reserialize(out, userVersion);
((WaitingOnSerializer.Provider)waitingOn).reserialize(out);
break;
case WRITES:
Invariants.require(writes != null);
@ -710,13 +717,13 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
break;
case RESULT:
Invariants.require(result != null);
ResultSerializers.result.serialize(result, out, userVersion);
ResultSerializers.result.serialize(result, out);
break;
}
}
}
public void deserializeNext(DataInputPlus in, int userVersion) throws IOException
public void deserializeNext(DataInputPlus in, Version userVersion) throws IOException
{
Invariants.require(txnId != null);
int readFlags = in.readInt();
@ -742,7 +749,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
this.flags |= readFlags & (~readFlags << 16);
}
private void deserialize(Field field, DataInputPlus in, int userVersion) throws IOException
private void deserialize(Field field, DataInputPlus in, Version userVersion) throws IOException
{
switch (field)
{
@ -762,10 +769,10 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
durability = Durability.values()[in.readByte()];
break;
case ACCEPTED:
acceptedOrCommitted = CommandSerializers.ballot.deserialize(in, userVersion);
acceptedOrCommitted = CommandSerializers.ballot.deserialize(in);
break;
case PROMISED:
promised = CommandSerializers.ballot.deserialize(in, userVersion);
promised = CommandSerializers.ballot.deserialize(in);
break;
case PARTICIPANTS:
participants = CommandSerializers.participants.deserialize(in, userVersion);
@ -774,7 +781,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
partialTxn = CommandSerializers.partialTxn.deserialize(in, userVersion);
break;
case PARTIAL_DEPS:
partialDeps = DepsSerializers.partialDeps.deserialize(in, userVersion);
partialDeps = DepsSerializers.partialDeps.deserialize(in);
break;
case WAITING_ON:
waitingOn = WaitingOnSerializer.deserializeProvider(txnId, in);
@ -788,12 +795,12 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
cleanup = newCleanup;
break;
case RESULT:
result = ResultSerializers.result.deserialize(in, userVersion);
result = ResultSerializers.result.deserialize(in);
break;
}
}
private static void skip(TxnId txnId, Field field, DataInputPlus in, int userVersion) throws IOException
private static void skip(TxnId txnId, Field field, DataInputPlus in, Version userVersion) throws IOException
{
switch (field)
{
@ -824,7 +831,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
break;
case PARTIAL_DEPS:
// TODO (expected): skip
DepsSerializers.partialDeps.deserialize(in, userVersion);
DepsSerializers.partialDeps.deserialize(in);
break;
case WAITING_ON:
WaitingOnSerializer.skip(txnId, in);
@ -835,7 +842,7 @@ public class AccordJournal implements accord.api.Journal, RangeSearcher.Supplier
break;
case RESULT:
// TODO (expected): skip
ResultSerializers.result.deserialize(in, userVersion);
ResultSerializers.result.deserialize(in);
break;
}
}

11
src/java/org/apache/cassandra/service/accord/AccordJournalTable.java
View File

@ -73,6 +73,7 @@ import org.apache.cassandra.journal.KeySupport;
import org.apache.cassandra.journal.RecordConsumer;
import org.apache.cassandra.schema.ColumnMetadata;
import org.apache.cassandra.service.accord.api.TokenKey;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.CloseableIterator;
import org.apache.cassandra.utils.FBUtilities;
import org.apache.cassandra.utils.JVMStabilityInspector;
@ -98,9 +99,9 @@ public class AccordJournalTable<K extends JournalKey, V> implements RangeSearche
*/
@Nullable
private final RouteInMemoryIndex<Object> index;
private final int accordJournalVersion;
private final Version accordJournalVersion;
public AccordJournalTable(Journal<K, V> journal, KeySupport<K> keySupport, ColumnFamilyStore cfs, int accordJournalVersion)
public AccordJournalTable(Journal<K, V> journal, KeySupport<K> keySupport, ColumnFamilyStore cfs, Version accordJournalVersion)
{
this.journal = journal;
this.cfs = cfs;
@ -150,7 +151,7 @@ public class AccordJournalTable<K extends JournalKey, V> implements RangeSearche
public interface Reader
{
void read(DataInputPlus input, int userVersion) throws IOException;
void read(DataInputPlus input, Version userVersion) throws IOException;
}
private class RecordConsumerAdapter implements RecordConsumer<K>
@ -174,7 +175,7 @@ public class AccordJournalTable<K extends JournalKey, V> implements RangeSearche
prevPosition = -1;
Invariants.require(prevPosition == -1 || position < prevPosition,
"Records should always be iterated over in a reverse order, but %s was seen after %s", position, prevPosition);
readBuffer(buffer, reader, userVersion);
readBuffer(buffer, reader, Version.fromVersion(userVersion));
prevSegment = segment;
prevPosition = position;
}
@ -486,7 +487,7 @@ public class AccordJournalTable<K extends JournalKey, V> implements RangeSearche
}
}
public static void readBuffer(ByteBuffer buffer, Reader reader, int userVersion)
public static void readBuffer(ByteBuffer buffer, Reader reader, Version userVersion)
{
try (DataInputBuffer in = new DataInputBuffer(buffer, false))
{

67
src/java/org/apache/cassandra/service/accord/AccordJournalValueSerializers.java
View File

@ -30,9 +30,9 @@ import accord.primitives.Timestamp;
import accord.primitives.TxnId;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.net.MessagingService;
import org.apache.cassandra.service.accord.journal.AccordTopologyUpdate;
import org.apache.cassandra.service.accord.serializers.CommandStoreSerializers;
import org.apache.cassandra.service.accord.serializers.Version;
import static accord.api.Journal.Load.ALL;
import static accord.local.CommandStores.RangesForEpoch;
@ -42,16 +42,15 @@ import static accord.local.CommandStores.RangesForEpoch;
// TODO (required): versioning
public class AccordJournalValueSerializers
{
private static final int messagingVersion = MessagingService.VERSION_40;
public interface FlyweightSerializer<ENTRY, IMAGE>
{
IMAGE mergerFor(JournalKey key);
void serialize(JournalKey key, ENTRY from, DataOutputPlus out, int userVersion) throws IOException;
void serialize(JournalKey key, ENTRY from, DataOutputPlus out, Version userVersion) throws IOException;
void reserialize(JournalKey key, IMAGE from, DataOutputPlus out, int userVersion) throws IOException;
void reserialize(JournalKey key, IMAGE from, DataOutputPlus out, Version userVersion) throws IOException;
void deserialize(JournalKey key, IMAGE into, DataInputPlus in, int userVersion) throws IOException;
void deserialize(JournalKey key, IMAGE into, DataInputPlus in, Version userVersion) throws IOException;
}
public static class CommandDiffSerializer
@ -64,7 +63,7 @@ public class AccordJournalValueSerializers
}
@Override
public void serialize(JournalKey key, AccordJournal.Writer writer, DataOutputPlus out, int userVersion)
public void serialize(JournalKey key, AccordJournal.Writer writer, DataOutputPlus out, Version userVersion)
{
try
{
@ -77,7 +76,7 @@ public class AccordJournalValueSerializers
}
@Override
public void reserialize(JournalKey key, AccordJournal.Builder from, DataOutputPlus out, int userVersion) throws IOException
public void reserialize(JournalKey key, AccordJournal.Builder from, DataOutputPlus out, Version userVersion) throws IOException
{
from.serialize(out,
// In CompactionIterator, we are dealing with relatively recent records, so we do not pass redundant before here.
@ -86,7 +85,7 @@ public class AccordJournalValueSerializers
}
@Override
public void deserialize(JournalKey journalKey, AccordJournal.Builder into, DataInputPlus in, int userVersion) throws IOException
public void deserialize(JournalKey journalKey, AccordJournal.Builder into, DataInputPlus in, Version userVersion) throws IOException
{
into.deserializeNext(in, userVersion);
}
@ -142,7 +141,7 @@ public class AccordJournalValueSerializers
}
@Override
public void serialize(JournalKey key, RedundantBefore entry, DataOutputPlus out, int userVersion)
public void serialize(JournalKey key, RedundantBefore entry, DataOutputPlus out, Version userVersion)
{
try
{
@ -152,7 +151,7 @@ public class AccordJournalValueSerializers
return;
}
out.writeInt(1);
CommandStoreSerializers.redundantBefore.serialize(entry, out, messagingVersion);
CommandStoreSerializers.redundantBefore.serialize(entry, out);
}
catch (IOException e)
{
@ -161,20 +160,20 @@ public class AccordJournalValueSerializers
}
@Override
public void reserialize(JournalKey key, IdentityAccumulator<RedundantBefore> from, DataOutputPlus out, int userVersion) throws IOException
public void reserialize(JournalKey key, IdentityAccumulator<RedundantBefore> from, DataOutputPlus out, Version userVersion) throws IOException
{
serialize(key, from.get(), out, userVersion);
}
@Override
public void deserialize(JournalKey journalKey, IdentityAccumulator<RedundantBefore> into, DataInputPlus in, int userVersion) throws IOException
public void deserialize(JournalKey journalKey, IdentityAccumulator<RedundantBefore> into, DataInputPlus in, Version userVersion) throws IOException
{
if (in.readInt() == 0)
{
into.update(RedundantBefore.EMPTY);
return;
}
into.update(CommandStoreSerializers.redundantBefore.deserialize(in, messagingVersion));
into.update(CommandStoreSerializers.redundantBefore.deserialize(in));
}
}
@ -201,11 +200,11 @@ public class AccordJournalValueSerializers
}
@Override
public void serialize(JournalKey key, DurableBefore entry, DataOutputPlus out, int userVersion)
public void serialize(JournalKey key, DurableBefore entry, DataOutputPlus out, Version userVersion)
{
try
{
CommandStoreSerializers.durableBefore.serialize(entry, out, messagingVersion);
CommandStoreSerializers.durableBefore.serialize(entry, out);
}
catch (IOException e)
{
@ -214,17 +213,17 @@ public class AccordJournalValueSerializers
}
@Override
public void reserialize(JournalKey key, DurableBeforeAccumulator from, DataOutputPlus out, int userVersion) throws IOException
public void reserialize(JournalKey key, DurableBeforeAccumulator from, DataOutputPlus out, Version userVersion) throws IOException
{
serialize(key, from.get(), out, userVersion);
}
@Override
public void deserialize(JournalKey journalKey, DurableBeforeAccumulator into, DataInputPlus in, int userVersion) throws IOException
public void deserialize(JournalKey journalKey, DurableBeforeAccumulator into, DataInputPlus in, Version userVersion) throws IOException
{
// TODO: maybe using local serializer is not the best call here, but how do we distinguish
// between messaging and disk versioning?
into.update(CommandStoreSerializers.durableBefore.deserialize(in, messagingVersion));
into.update(CommandStoreSerializers.durableBefore.deserialize(in));
}
}
@ -238,21 +237,21 @@ public class AccordJournalValueSerializers
}
@Override
public void serialize(JournalKey key, NavigableMap<TxnId, Ranges> entry, DataOutputPlus out, int userVersion) throws IOException
public void serialize(JournalKey key, NavigableMap<TxnId, Ranges> entry, DataOutputPlus out, Version userVersion) throws IOException
{
CommandStoreSerializers.bootstrapBeganAt.serialize(entry, out, messagingVersion);
CommandStoreSerializers.bootstrapBeganAt.serialize(entry, out);
}
@Override
public void reserialize(JournalKey key, IdentityAccumulator<NavigableMap<TxnId, Ranges>> image, DataOutputPlus out, int userVersion) throws IOException
public void reserialize(JournalKey key, IdentityAccumulator<NavigableMap<TxnId, Ranges>> image, DataOutputPlus out, Version userVersion) throws IOException
{
serialize(key, image.get(), out, userVersion);
}
@Override
public void deserialize(JournalKey key, IdentityAccumulator<NavigableMap<TxnId, Ranges>> into, DataInputPlus in, int userVersion) throws IOException
public void deserialize(JournalKey key, IdentityAccumulator<NavigableMap<TxnId, Ranges>> into, DataInputPlus in, Version userVersion) throws IOException
{
into.update(CommandStoreSerializers.bootstrapBeganAt.deserialize(in, messagingVersion));
into.update(CommandStoreSerializers.bootstrapBeganAt.deserialize(in));
}
}
@ -266,21 +265,21 @@ public class AccordJournalValueSerializers
}
@Override
public void serialize(JournalKey key, NavigableMap<Timestamp, Ranges> from, DataOutputPlus out, int userVersion) throws IOException
public void serialize(JournalKey key, NavigableMap<Timestamp, Ranges> from, DataOutputPlus out, Version userVersion) throws IOException
{
CommandStoreSerializers.safeToRead.serialize(from, out, messagingVersion);
CommandStoreSerializers.safeToRead.serialize(from, out);
}
@Override
public void reserialize(JournalKey key, IdentityAccumulator<NavigableMap<Timestamp, Ranges>> from, DataOutputPlus out, int userVersion) throws IOException
public void reserialize(JournalKey key, IdentityAccumulator<NavigableMap<Timestamp, Ranges>> from, DataOutputPlus out, Version userVersion) throws IOException
{
serialize(key, from.get(), out, userVersion);
}
@Override
public void deserialize(JournalKey key, IdentityAccumulator<NavigableMap<Timestamp, Ranges>> into, DataInputPlus in, int userVersion) throws IOException
public void deserialize(JournalKey key, IdentityAccumulator<NavigableMap<Timestamp, Ranges>> into, DataInputPlus in, Version userVersion) throws IOException
{
into.update(CommandStoreSerializers.safeToRead.deserialize(in, messagingVersion));
into.update(CommandStoreSerializers.safeToRead.deserialize(in));
}
}
@ -294,21 +293,21 @@ public class AccordJournalValueSerializers
}
@Override
public void serialize(JournalKey key, RangesForEpoch from, DataOutputPlus out, int userVersion) throws IOException
public void serialize(JournalKey key, RangesForEpoch from, DataOutputPlus out, Version userVersion) throws IOException
{
AccordTopologyUpdate.RangesForEpochSerializer.instance.serialize(from, out, userVersion);
AccordTopologyUpdate.RangesForEpochSerializer.instance.serialize(from, out);
}
@Override
public void reserialize(JournalKey key, Accumulator<RangesForEpoch, RangesForEpoch> from, DataOutputPlus out, int userVersion) throws IOException
public void reserialize(JournalKey key, Accumulator<RangesForEpoch, RangesForEpoch> from, DataOutputPlus out, Version userVersion) throws IOException
{
serialize(key, from.get(), out, messagingVersion);
serialize(key, from.get(), out, userVersion);
}
@Override
public void deserialize(JournalKey key, Accumulator<RangesForEpoch, RangesForEpoch> into, DataInputPlus in, int userVersion) throws IOException
public void deserialize(JournalKey key, Accumulator<RangesForEpoch, RangesForEpoch> into, DataInputPlus in, Version userVersion) throws IOException
{
into.update(AccordTopologyUpdate.RangesForEpochSerializer.instance.deserialize(in, userVersion));
into.update(AccordTopologyUpdate.RangesForEpochSerializer.instance.deserialize(in));
}
}
}

3
src/java/org/apache/cassandra/service/accord/AccordSegmentCompactor.java
View File

@ -22,6 +22,7 @@ import org.apache.cassandra.db.SerializationHeader;
import org.apache.cassandra.db.rows.EncodingStats;
import org.apache.cassandra.io.sstable.Descriptor;
import org.apache.cassandra.io.sstable.SSTableTxnWriter;
import org.apache.cassandra.service.accord.serializers.Version;
/**
* Segment compactor: takes static segments and compacts them into a single SSTable.
@ -30,7 +31,7 @@ public class AccordSegmentCompactor<V> extends AbstractAccordSegmentCompactor<V>
{
private SSTableTxnWriter writer;
public AccordSegmentCompactor(int userVersion, ColumnFamilyStore cfs)
public AccordSegmentCompactor(Version userVersion, ColumnFamilyStore cfs)
{
super(userVersion, cfs);
}

114
src/java/org/apache/cassandra/service/accord/AccordSerializerVersion.java
View File

@ -1,114 +0,0 @@
/*
* 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.apache.cassandra.service.accord;
import java.io.IOException;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.MessageVersionProvider;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.net.MessagingService;
public enum AccordSerializerVersion implements MessageVersionProvider
{
// If MessagingService version bumps, this mapping does not need to be updated; only updates needed are those that
// include accord serializer changes.
V1(1, MessagingService.VERSION_40);
public static final AccordSerializerVersion CURRENT = V1;
public static final Serializer serializer = new Serializer();
public final int version;
public final int msgVersion;
AccordSerializerVersion(int version, int msgVersion)
{
this.version = version;
this.msgVersion = msgVersion;
}
public static AccordSerializerVersion fromVersion(int version)
{
switch (version)
{
case 1:
return V1;
default:
throw new IllegalArgumentException();
}
}
public static AccordSerializerVersion fromMessageVersion(int version)
{
AccordSerializerVersion[] versions = values();
for (int i = versions.length - 1; i >= 0; i--)
{
AccordSerializerVersion v = versions[i];
// If network version bumped (12 to 13), the accord serializers may not have been changed; use the largest
// version smaller than or equal to this version
if (v.msgVersion <= version)
return v;
}
throw new IllegalArgumentException("Attempted to use message version " + version + " which is smaller than " + versions[0] + " can handle (" + versions[0].msgVersion + ")");
}
@Override
public int messageVersion()
{
return msgVersion;
}
public static class Serializer implements IVersionedSerializer<AccordSerializerVersion>
{
@Override
public void serialize(AccordSerializerVersion t, DataOutputPlus out, int version) throws IOException
{
serialize(t, out);
}
public void serialize(AccordSerializerVersion t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(t.version);
}
@Override
public AccordSerializerVersion deserialize(DataInputPlus in, int version) throws IOException
{
return deserialize(in);
}
public AccordSerializerVersion deserialize(DataInputPlus in) throws IOException
{
return fromVersion(in.readUnsignedVInt32());
}
@Override
public long serializedSize(AccordSerializerVersion t, int version)
{
return serializedSize(t);
}
public long serializedSize(AccordSerializerVersion t)
{
return TypeSizes.sizeofUnsignedVInt(t.version);
}
}
}

106
src/java/org/apache/cassandra/service/accord/AccordSerializers.java
View File

@ -20,7 +20,6 @@ package org.apache.cassandra.service.accord;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.List;
import org.apache.cassandra.cql3.terms.MultiElements;
import org.apache.cassandra.cql3.terms.Term;
@ -36,16 +35,17 @@ import org.apache.cassandra.db.marshal.SetType;
import org.apache.cassandra.db.marshal.ValueAccessor;
import org.apache.cassandra.db.partitions.PartitionUpdate;
import org.apache.cassandra.db.rows.DeserializationHelper;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.AsymmetricVersionedSerializer;
import org.apache.cassandra.io.EmbeddedAsymmetricVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.net.MessagingService;
import org.apache.cassandra.schema.ColumnMetadata;
import org.apache.cassandra.schema.Schema;
import org.apache.cassandra.schema.TableId;
import org.apache.cassandra.schema.TableMetadata;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.ByteBufferUtil;
import static org.apache.cassandra.db.TypeSizes.sizeof;
@ -56,41 +56,9 @@ import static org.apache.cassandra.db.marshal.CollectionType.Kind.SET;
public class AccordSerializers
{
public static <T> ByteBuffer serialize(T item, IVersionedSerializer<T> serializer)
public static <A, B> EmbeddedAsymmetricVersionedSerializer<A, B, Version> embedded(Version version, AsymmetricVersionedSerializer<A, B, Version> serializer)
{
int version = MessagingService.current_version;
long size = serializer.serializedSize(item, version) + sizeofUnsignedVInt(version);
try (DataOutputBuffer out = new DataOutputBuffer((int) size))
{
out.writeUnsignedVInt32(version);
serializer.serialize(item, out, version);
return out.buffer(false);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
public static <T> ByteBuffer[] serialize(List<T> items, IVersionedSerializer<T> serializer)
{
ByteBuffer[] result = new ByteBuffer[items.size()];
for (int i = 0, mi = items.size(); i < mi; i++)
result[i] = serialize(items.get(i), serializer);
return result;
}
public static <T> T deserialize(ByteBuffer bytes, IVersionedSerializer<T> serializer)
{
try (DataInputBuffer in = new DataInputBuffer(bytes, true))
{
int version = in.readUnsignedVInt32();
return serializer.deserialize(in, version);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
return new EmbeddedAsymmetricVersionedSerializer<>(version, Version.Serializer.instance, serializer);
}
public static Term.Terminal deserializeCqlCollectionAsTerm(ByteBuffer buffer, AbstractType<?> type)
@ -110,28 +78,28 @@ public class AccordSerializers
public static final IVersionedSerializer<PartitionUpdate> partitionUpdateSerializer = new IVersionedSerializer<PartitionUpdate>()
{
@Override
public void serialize(PartitionUpdate upd, DataOutputPlus out, int version) throws IOException
public void serialize(PartitionUpdate upd, DataOutputPlus out, Version version) throws IOException
{
PartitionUpdate.serializer.serialize(upd, out, version);
PartitionUpdate.serializer.serialize(upd, out, version.messageVersion());
}
@Override
public PartitionUpdate deserialize(DataInputPlus in, int version) throws IOException
public PartitionUpdate deserialize(DataInputPlus in, Version version) throws IOException
{
return PartitionUpdate.serializer.deserialize(in, version, DeserializationHelper.Flag.FROM_REMOTE);
return PartitionUpdate.serializer.deserialize(in, version.messageVersion(), DeserializationHelper.Flag.FROM_REMOTE);
}
@Override
public long serializedSize(PartitionUpdate upd, int version)
public long serializedSize(PartitionUpdate upd, Version version)
{
return PartitionUpdate.serializer.serializedSize(upd, version);
return PartitionUpdate.serializer.serializedSize(upd, version.messageVersion());
}
};
public static final IVersionedSerializer<ColumnMetadata> columnMetadataSerializer = new IVersionedSerializer<>()
public static final UnversionedSerializer<ColumnMetadata> columnMetadataSerializer = new UnversionedSerializer<ColumnMetadata>()
{
@Override
public void serialize(ColumnMetadata column, DataOutputPlus out, int version) throws IOException
public void serialize(ColumnMetadata column, DataOutputPlus out) throws IOException
{
out.writeUTF(column.ksName);
out.writeUTF(column.cfName);
@ -139,7 +107,7 @@ public class AccordSerializers
}
@Override
public ColumnMetadata deserialize(DataInputPlus in, int version) throws IOException
public ColumnMetadata deserialize(DataInputPlus in) throws IOException
{
String keyspace = in.readUTF();
String table = in.readUTF();
@ -148,7 +116,7 @@ public class AccordSerializers
}
@Override
public long serializedSize(ColumnMetadata column, int version)
public long serializedSize(ColumnMetadata column)
{
long size = 0;
size += sizeof(column.ksName);
@ -161,33 +129,33 @@ public class AccordSerializers
public static final IVersionedSerializer<TableMetadata> tableMetadataSerializer = new IVersionedSerializer<TableMetadata>()
{
@Override
public void serialize(TableMetadata metadata, DataOutputPlus out, int version) throws IOException
public void serialize(TableMetadata metadata, DataOutputPlus out, Version version) throws IOException
{
metadata.id.serializeCompact(out);
}
@Override
public TableMetadata deserialize(DataInputPlus in, int version) throws IOException
public TableMetadata deserialize(DataInputPlus in, Version version) throws IOException
{
return Schema.instance.getTableMetadata(TableId.deserializeCompact(in));
}
@Override
public long serializedSize(TableMetadata metadata, int version)
public long serializedSize(TableMetadata metadata, Version version)
{
return metadata.id.serializedCompactSize();
}
};
public static final IVersionedSerializer<Clustering<?>> clusteringSerializer = new IVersionedSerializer<Clustering<?>>()
public static final UnversionedSerializer<Clustering<?>> clusteringSerializer = new UnversionedSerializer<Clustering<?>>()
{
@Override
public void serialize(Clustering<?> clustering, DataOutputPlus out, int version) throws IOException
public void serialize(Clustering<?> clustering, DataOutputPlus out) throws IOException
{
doSerialize(clustering, out);
}
public <V> void doSerialize(Clustering<V> clustering, DataOutputPlus out) throws IOException
private <V> void doSerialize(Clustering<V> clustering, DataOutputPlus out) throws IOException
{
if (clustering.kind() == ClusteringPrefix.Kind.STATIC_CLUSTERING)
{
@ -206,7 +174,7 @@ public class AccordSerializers
}
@Override
public Clustering<?> deserialize(DataInputPlus in, int version) throws IOException
public Clustering<?> deserialize(DataInputPlus in) throws IOException
{
Clustering<?> clustering;
if (in.readBoolean())
@ -229,41 +197,45 @@ public class AccordSerializers
}
@Override
public long serializedSize(Clustering<?> clustering, int version)
public long serializedSize(Clustering<?> clustering)
{
return computeSerializedSize(clustering);
}
private <V> long computeSerializedSize(Clustering<V> clustering)
{
int size = sizeof(true) + sizeofUnsignedVInt(clustering.size());
ValueAccessor<V> accessor = clustering.accessor();
for (int i = 0; i < clustering.size(); i++)
int size = sizeof(true);
if (clustering.kind() != ClusteringPrefix.Kind.STATIC_CLUSTERING)
{
int valueSize = accessor.size(clustering.get(i));
size += valueSize;
size += sizeofUnsignedVInt(valueSize);
size += sizeofUnsignedVInt(clustering.size());
ValueAccessor<V> accessor = clustering.accessor();
for (int i = 0; i < clustering.size(); i++)
{
int valueSize = accessor.size(clustering.get(i));
size += valueSize;
size += sizeofUnsignedVInt(valueSize);
}
}
return size;
}
};
public static final IVersionedSerializer<ConsistencyLevel> consistencyLevelSerializer = new IVersionedSerializer<ConsistencyLevel>()
public static final UnversionedSerializer<ConsistencyLevel> consistencyLevelSerializer = new UnversionedSerializer<ConsistencyLevel>()
{
@Override
public void serialize(ConsistencyLevel t, DataOutputPlus out, int version) throws IOException
public void serialize(ConsistencyLevel t, DataOutputPlus out) throws IOException
{
out.writeByte(t.code);
}
@Override
public ConsistencyLevel deserialize(DataInputPlus in, int version) throws IOException
public ConsistencyLevel deserialize(DataInputPlus in) throws IOException
{
return ConsistencyLevel.fromCode(in.readByte());
}
@Override
public long serializedSize(ConsistencyLevel t, int version)
public long serializedSize(ConsistencyLevel t)
{
return 1;
}

6
src/java/org/apache/cassandra/service/accord/AccordStaleReplicas.java
View File

@ -116,21 +116,21 @@ public class AccordStaleReplicas implements MetadataValue<AccordStaleReplicas>
@Override
public void serialize(AccordStaleReplicas replicas, DataOutputPlus out, Version version) throws IOException
{
CollectionSerializers.serializeCollection(replicas.staleIds, out, version, TopologySerializers.nodeId);
CollectionSerializers.serializeCollection(replicas.staleIds, out, TopologySerializers.nodeId);
Epoch.serializer.serialize(replicas.lastModified, out, version);
}
@Override
public AccordStaleReplicas deserialize(DataInputPlus in, Version version) throws IOException
{
return new AccordStaleReplicas(CollectionSerializers.deserializeSet(in, version, TopologySerializers.nodeId),
return new AccordStaleReplicas(CollectionSerializers.deserializeSet(in, TopologySerializers.nodeId),
Epoch.serializer.deserialize(in, version));
}
@Override
public long serializedSize(AccordStaleReplicas replicas, Version version)
{
return CollectionSerializers.serializedCollectionSize(replicas.staleIds, version, TopologySerializers.nodeId)
return CollectionSerializers.serializedCollectionSize(replicas.staleIds, TopologySerializers.nodeId)
+ Epoch.serializer.serializedSize(replicas.lastModified, version);
}
};

28
src/java/org/apache/cassandra/service/accord/AccordSyncPropagator.java
View File

@ -42,7 +42,7 @@ import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.exceptions.RequestFailure;
import org.apache.cassandra.gms.Gossiper;
import org.apache.cassandra.gms.IFailureDetector;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.locator.InetAddressAndPort;
@ -363,33 +363,33 @@ public class AccordSyncPropagator
public static class Notification
{
public static final IVersionedSerializer<Notification> serializer = new IVersionedSerializer<>()
public static final UnversionedSerializer<Notification> serializer = new UnversionedSerializer<Notification>()
{
@Override
public void serialize(Notification notification, DataOutputPlus out, int version) throws IOException
public void serialize(Notification notification, DataOutputPlus out) throws IOException
{
out.writeLong(notification.epoch);
CollectionSerializers.serializeCollection(notification.syncComplete, out, version, TopologySerializers.nodeId);
KeySerializers.ranges.serialize(notification.closed, out, version);
KeySerializers.ranges.serialize(notification.retired, out, version);
CollectionSerializers.serializeCollection(notification.syncComplete, out, TopologySerializers.nodeId);
KeySerializers.ranges.serialize(notification.closed, out);
KeySerializers.ranges.serialize(notification.retired, out);
}
@Override
public Notification deserialize(DataInputPlus in, int version) throws IOException
public Notification deserialize(DataInputPlus in) throws IOException
{
return new Notification(in.readLong(),
CollectionSerializers.deserializeList(in, version, TopologySerializers.nodeId),
KeySerializers.ranges.deserialize(in, version),
KeySerializers.ranges.deserialize(in, version));
CollectionSerializers.deserializeList(in, TopologySerializers.nodeId),
KeySerializers.ranges.deserialize(in),
KeySerializers.ranges.deserialize(in));
}
@Override
public long serializedSize(Notification notification, int version)
public long serializedSize(Notification notification)
{
return TypeSizes.LONG_SIZE
+ CollectionSerializers.serializedCollectionSize(notification.syncComplete, version, TopologySerializers.nodeId)
+ KeySerializers.ranges.serializedSize(notification.closed, version)
+ KeySerializers.ranges.serializedSize(notification.retired, version);
+ CollectionSerializers.serializedCollectionSize(notification.syncComplete, TopologySerializers.nodeId)
+ KeySerializers.ranges.serializedSize(notification.closed)
+ KeySerializers.ranges.serializedSize(notification.retired);
}
};

25
src/java/org/apache/cassandra/service/accord/FetchTopologies.java
View File

@ -29,7 +29,7 @@ import org.slf4j.LoggerFactory;
import accord.topology.Topology;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.exceptions.RequestFailure;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.locator.InetAddressAndPort;
@ -61,23 +61,23 @@ public class FetchTopologies
private final long minEpoch;
private final long maxEpoch;
public static final IVersionedSerializer<FetchTopologies> serializer = new IVersionedSerializer<>()
public static final UnversionedSerializer<FetchTopologies> serializer = new UnversionedSerializer<>()
{
@Override
public void serialize(FetchTopologies t, DataOutputPlus out, int version) throws IOException
public void serialize(FetchTopologies t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt(t.minEpoch);
out.writeUnsignedVInt(t.maxEpoch);
}
@Override
public FetchTopologies deserialize(DataInputPlus in, int version) throws IOException
public FetchTopologies deserialize(DataInputPlus in) throws IOException
{
return new FetchTopologies(in.readUnsignedVInt(), in.readUnsignedVInt());
}
@Override
public long serializedSize(FetchTopologies t, int version)
public long serializedSize(FetchTopologies t)
{
return TypeSizes.sizeofUnsignedVInt(t.minEpoch) +
TypeSizes.sizeofUnsignedVInt(t.maxEpoch);
@ -90,11 +90,10 @@ public class FetchTopologies
this.maxEpoch = maxEpoch;
}
// TODO (required): messaging version after version patch
public static final IVersionedSerializer<TopologyRange> responseSerializer = new IVersionedSerializer<>()
public static final UnversionedSerializer<TopologyRange> responseSerializer = new UnversionedSerializer<>()
{
@Override
public void serialize(TopologyRange t, DataOutputPlus out, int version) throws IOException
public void serialize(TopologyRange t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt(t.min);
out.writeUnsignedVInt(t.current);
@ -102,11 +101,11 @@ public class FetchTopologies
out.writeUnsignedVInt32(t.topologies.size());
for (Topology topology : t.topologies)
TopologySerializers.topology.serialize(topology, out, version);
TopologySerializers.topology.serialize(topology, out);
}
@Override
public TopologyRange deserialize(DataInputPlus in, int version) throws IOException
public TopologyRange deserialize(DataInputPlus in) throws IOException
{
long min = in.readUnsignedVInt();
long current = in.readUnsignedVInt();
@ -114,19 +113,19 @@ public class FetchTopologies
int count = in.readUnsignedVInt32();
List<Topology> topologies = new ArrayList<>(count);
for (int i = 0; i < count; ++i)
topologies.add(TopologySerializers.topology.deserialize(in, version));
topologies.add(TopologySerializers.topology.deserialize(in));
return new TopologyRange(min, current, firstNonEmpty, topologies);
}
@Override
public long serializedSize(TopologyRange t, int version)
public long serializedSize(TopologyRange t)
{
long size = TypeSizes.sizeofUnsignedVInt(t.min);
size += TypeSizes.sizeofUnsignedVInt(t.current);
size += TypeSizes.sizeofUnsignedVInt(t.firstNonEmpty);
size += TypeSizes.sizeofUnsignedVInt(t.topologies.size());
for (Topology topology : t.topologies)
size += TopologySerializers.topology.serializedSize(topology, version);
size += TopologySerializers.topology.serializedSize(topology);
return size;
}
};

28
src/java/org/apache/cassandra/service/accord/TokenRange.java
View File

@ -29,7 +29,7 @@ import org.apache.cassandra.config.DatabaseDescriptor;
import org.apache.cassandra.dht.IPartitioner;
import org.apache.cassandra.dht.Murmur3Partitioner;
import org.apache.cassandra.dht.Token;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.TableId;
@ -120,33 +120,33 @@ public class TokenRange extends Range.EndInclusive
public static final Serializer serializer = new Serializer();
public static final class Serializer implements IVersionedSerializer<TokenRange>
public static final class Serializer implements UnversionedSerializer<TokenRange>
{
@Override
public void serialize(TokenRange range, DataOutputPlus out, int version) throws IOException
public void serialize(TokenRange range, DataOutputPlus out) throws IOException
{
TokenKey.serializer.serialize(range.start(), out, version);
TokenKey.serializer.serialize(range.end(), out, version);
TokenKey.serializer.serialize(range.start(), out);
TokenKey.serializer.serialize(range.end(), out);
}
public void skip(DataInputPlus in, int version) throws IOException
public void skip(DataInputPlus in) throws IOException
{
TokenKey.serializer.skip(in, version);
TokenKey.serializer.skip(in, version);
TokenKey.serializer.skip(in);
TokenKey.serializer.skip(in);
}
@Override
public TokenRange deserialize(DataInputPlus in, int version) throws IOException
public TokenRange deserialize(DataInputPlus in) throws IOException
{
return TokenRange.create(TokenKey.serializer.deserialize(in, version),
TokenKey.serializer.deserialize(in, version));
return TokenRange.create(TokenKey.serializer.deserialize(in),
TokenKey.serializer.deserialize(in));
}
@Override
public long serializedSize(TokenRange range, int version)
public long serializedSize(TokenRange range)
{
return TokenKey.serializer.serializedSize(range.start(), version)
+ TokenKey.serializer.serializedSize(range.end(), version);
return TokenKey.serializer.serializedSize(range.start())
+ TokenKey.serializer.serializedSize(range.end());
}
};
}

41
src/java/org/apache/cassandra/service/accord/WatermarkCollector.java
View File

@ -22,6 +22,7 @@ import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import com.google.common.annotations.VisibleForTesting;
@ -38,7 +39,7 @@ import accord.utils.Invariants;
import accord.utils.async.AsyncResult;
import org.agrona.collections.Int2ObjectHashMap;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.locator.InetAddressAndPort;
@ -172,22 +173,38 @@ public class WatermarkCollector implements ConfigurationService.Listener
this.retired = retired;
this.synced = synced;
}
@Override
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Snapshot snapshot = (Snapshot) o;
return closed.equals(snapshot.closed) && retired.equals(snapshot.retired) && synced.equals(snapshot.synced);
}
@Override
public int hashCode()
{
return Objects.hash(closed, retired, synced);
}
}
public static final IVersionedSerializer<Snapshot> serializer = new IVersionedSerializer<>()
public static final UnversionedSerializer<Snapshot> serializer = new UnversionedSerializer<>()
{
public void serialize(Snapshot t, DataOutputPlus out, int version) throws IOException
@Override
public void serialize(Snapshot t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(t.closed.size());
for (Map.Entry<Range, Long> e : t.closed.entrySet())
{
TokenRange.serializer.serialize((TokenRange) e.getKey(), out, version);
TokenRange.serializer.serialize((TokenRange) e.getKey(), out);
out.writeUnsignedVInt(e.getValue());
}
out.writeUnsignedVInt32(t.retired.size());
for (Map.Entry<Range, Long> e : t.retired.entrySet())
{
TokenRange.serializer.serialize((TokenRange) e.getKey(), out, version);
TokenRange.serializer.serialize((TokenRange) e.getKey(), out);
out.writeUnsignedVInt(e.getValue());
}
out.writeUnsignedVInt32(t.synced.size());
@ -199,20 +216,21 @@ public class WatermarkCollector implements ConfigurationService.Listener
}
// TODO (desired): we do not have to deserialize to report these values
public Snapshot deserialize(DataInputPlus in, int version) throws IOException
@Override
public Snapshot deserialize(DataInputPlus in) throws IOException
{
int closedSize = in.readUnsignedVInt32();
Map<Range, Long> closed = new HashMap<>();
for (int i = 0; i < closedSize; i++)
{
closed.put(TokenRange.serializer.deserialize(in, version),
closed.put(TokenRange.serializer.deserialize(in),
in.readUnsignedVInt());
}
int retiredSize = in.readUnsignedVInt32();
Map<Range, Long> retired = new HashMap<>();
for (int i = 0; i < retiredSize; i++)
{
retired.put(TokenRange.serializer.deserialize(in, version),
retired.put(TokenRange.serializer.deserialize(in),
in.readUnsignedVInt());
}
int syncedSize = in.readUnsignedVInt32();
@ -225,19 +243,20 @@ public class WatermarkCollector implements ConfigurationService.Listener
return new Snapshot(closed, retired, synced);
}
public long serializedSize(Snapshot t, int version)
@Override
public long serializedSize(Snapshot t)
{
int size = 0;
size += TypeSizes.sizeofUnsignedVInt(t.closed.size());
for (Map.Entry<Range, Long> e : t.closed.entrySet())
{
size += TokenRange.serializer.serializedSize((TokenRange) e.getKey(), version);
size += TokenRange.serializer.serializedSize((TokenRange) e.getKey());
size += TypeSizes.sizeofUnsignedVInt(e.getValue());
}
size += TypeSizes.sizeofUnsignedVInt(t.retired.size());
for (Map.Entry<Range, Long> e : t.retired.entrySet())
{
size += TokenRange.serializer.serializedSize((TokenRange) e.getKey(), version);
size += TokenRange.serializer.serializedSize((TokenRange) e.getKey());
size += TypeSizes.sizeofUnsignedVInt(e.getValue());
}
size += TypeSizes.sizeofUnsignedVInt(t.synced.size());

15
src/java/org/apache/cassandra/service/accord/api/AccordRoutableKey.java
View File

@ -24,16 +24,16 @@ import javax.annotation.Nonnull;
import accord.primitives.RoutableKey;
import org.apache.cassandra.dht.Token;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.TableId;
public abstract class AccordRoutableKey implements RoutableKey
{
public interface AccordKeySerializer<K> extends IVersionedSerializer<K>
public interface AccordKeySerializer<K> extends UnversionedSerializer<K>
{
void skip(DataInputPlus in, int version) throws IOException;
void skip(DataInputPlus in) throws IOException;
}
public interface AccordSearchableKeySerializer<K> extends AccordKeySerializer<K>
@ -42,15 +42,16 @@ public abstract class AccordRoutableKey implements RoutableKey
int fixedKeyLengthForPrefix(Object prefix);
int serializedSizeOfPrefix(Object prefix);
int serializedSizeWithoutPrefix(K key);
void serializePrefix(Object prefix, DataOutputPlus out, int version) throws IOException;
void serializeWithoutPrefixOrLength(K key, DataOutputPlus out, int version) throws IOException;
Object deserializePrefix(DataInputPlus in, int version) throws IOException;
K deserializeWithPrefix(Object prefix, int length, DataInputPlus in, int version) throws IOException;
void serializePrefix(Object prefix, DataOutputPlus out) throws IOException;
void serializeWithoutPrefixOrLength(K key, DataOutputPlus out) throws IOException;
Object deserializePrefix(DataInputPlus in) throws IOException;
K deserializeWithPrefix(Object prefix, int length, DataInputPlus in) throws IOException;
}
static final byte MAX_TABLE_SENTINEL = 0x48;
static final byte NORMAL_SENTINEL = 0x28;
static final byte BEFORE_TOKEN_SENTINEL = 0x24;
static final byte AFTER_TOKEN_SENTINEL = 0x2c;
static final byte MIN_TABLE_SENTINEL = 0x18;
static final int PREFIX_MASK = 0xF0;
static final int SUFFIX_MASK = 0x0F;

11
src/java/org/apache/cassandra/service/accord/api/PartitionKey.java
View File

@ -128,7 +128,7 @@ public final class PartitionKey extends AccordRoutableKey implements Key
private Serializer() {}
@Override
public void serialize(PartitionKey key, DataOutputPlus out, int version) throws IOException
public void serialize(PartitionKey key, DataOutputPlus out) throws IOException
{
key.table().serializeCompact(out);
ByteBufferUtil.writeWithShortLength(key.partitionKey().getKey(), out);
@ -149,14 +149,14 @@ public final class PartitionKey extends AccordRoutableKey implements Key
}
@Override
public void skip(DataInputPlus in, int version) throws IOException
public void skip(DataInputPlus in) throws IOException
{
TableId.skipCompact(in);
ByteBufferUtil.skipShortLength(in);
}
@Override
public PartitionKey deserialize(DataInputPlus in, int version) throws IOException
public PartitionKey deserialize(DataInputPlus in) throws IOException
{
TableId tableId = TableId.deserializeCompact(in).intern();
DecoratedKey key = getPartitioner().decorateKey(ByteBufferUtil.readWithShortLength(in));
@ -176,11 +176,6 @@ public final class PartitionKey extends AccordRoutableKey implements Key
}
@Override
public long serializedSize(PartitionKey key, int version)
{
return serializedSize(key);
}
public long serializedSize(PartitionKey key)
{
return key.table().serializedCompactSize() + ByteBufferUtil.serializedSizeWithShortLength(key.partitionKey().getKey());

79
src/java/org/apache/cassandra/service/accord/api/TokenKey.java
View File

@ -50,11 +50,6 @@ import static org.apache.cassandra.config.DatabaseDescriptor.getPartitioner;
public final class TokenKey extends AccordRoutableKey implements RoutingKey, RangeFactory
{
public enum RoutingKeyKind
{
TOKEN, SENTINEL, MIN_TOKEN
}
private static final long EMPTY_SIZE = ObjectSizes.measure(new TokenKey(null, null));
@Override
@ -66,7 +61,7 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
// we use the first 2 bits as a prefix, and the last 6 bits as a postfix comparison
final byte sentinel;
final Token token;
public TokenKey(TableId tableId, byte sentinel, Token token)
private TokenKey(TableId tableId, byte sentinel, Token token)
{
super(tableId);
this.sentinel = sentinel;
@ -109,6 +104,7 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
@VisibleForTesting
public TokenKey before()
{
Invariants.require(!isTokenSentinel(), "Unable to call .before() when already a token sentinel: %s", this);
int lowestBit = Integer.lowestOneBit(sentinel);
Invariants.require(lowestBit != 1);
byte newSentinel = (byte)((sentinel ^ lowestBit) | (lowestBit >>> 1));
@ -119,6 +115,7 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
@VisibleForTesting
public TokenKey after()
{
Invariants.require(!isTokenSentinel(), "Unable to call .after() when already a token sentinel: %s", this);
int lowestBit = Integer.lowestOneBit(sentinel);
// we can't use 0xf as we would not be able to disambiguate with variable length byte encoding escape
Invariants.require((lowestBit != 1) && (sentinel & 0xf) != 0xe);
@ -138,7 +135,7 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
if (isSentinel())
{
if (isTableSentinel()) suffix = isMin() ? "-Inf" : "+Inf";
else suffix = suffix + "(-epsilon)";
if (isTokenSentinel()) suffix = (isBefore() ? "before(" : "after(") + suffix + ')';
}
return suffix;
}
@ -149,16 +146,6 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
return prefix() + ":" + printableSuffix();
}
public boolean isMin()
{
return sentinel == MIN_TABLE_SENTINEL;
}
public boolean isMax()
{
return sentinel == MAX_TABLE_SENTINEL;
}
public long estimatedSizeOnHeap()
{
return EMPTY_SIZE + token().getHeapSize();
@ -193,6 +180,20 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
return this;
}
public boolean isMin()
{
//TODO (review): some code paths don't care if before/after are used, but some are not fully correct (range.isFullRange)
// return sentinel == MIN_TABLE_SENTINEL;
return (sentinel & PREFIX_MASK) == (MIN_TABLE_SENTINEL & PREFIX_MASK);
}
public boolean isMax()
{
//TODO (review): some code paths don't care if before/after are used, but some are not fully correct (range.isFullRange)
// return sentinel == MAX_TABLE_SENTINEL;
return (sentinel & PREFIX_MASK) == (MAX_TABLE_SENTINEL & PREFIX_MASK);
}
public boolean isSentinel()
{
return sentinel != NORMAL_SENTINEL;
@ -208,6 +209,16 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
return (sentinel & SUFFIX_MASK) != (NORMAL_SENTINEL & SUFFIX_MASK);
}
public boolean isBefore()
{
return (sentinel & SUFFIX_MASK) == (BEFORE_TOKEN_SENTINEL & SUFFIX_MASK);
}
public boolean isAfter()
{
return (sentinel & SUFFIX_MASK) == (AFTER_TOKEN_SENTINEL & SUFFIX_MASK);
}
public static TokenKey min(TableId table, IPartitioner partitioner)
{
return new TokenKey(table, MIN_TABLE_SENTINEL, partitioner.getMinimumToken());
@ -231,7 +242,7 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
// types are byte comparable only after any length component
@Override
public long serializedSize(TokenKey key, int version)
public long serializedSize(TokenKey key)
{
IPartitioner partitioner = key.token.getPartitioner();
int size = 2 + key.table.serializedCompactComparableSize();
@ -243,7 +254,7 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
}
@Override
public void serialize(TokenKey key, DataOutputPlus out, int version) throws IOException
public void serialize(TokenKey key, DataOutputPlus out) throws IOException
{
IPartitioner partitioner = key.token.getPartitioner();
int fixedLength = partitioner.accordFixedLength();
@ -253,30 +264,30 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
out.writeUnsignedVInt32(len);
}
key.table.serializeCompactComparable(out);
serializeWithoutPrefixOrLength(key, out, version);
serializeWithoutPrefixOrLength(key, out);
}
@Override
public TokenKey deserialize(DataInputPlus in, int version) throws IOException
public TokenKey deserialize(DataInputPlus in) throws IOException
{
return deserialize(in, version, getPartitioner());
return deserialize(in, getPartitioner());
}
public TokenKey deserialize(DataInputPlus in, int version, IPartitioner partitioner) throws IOException
public TokenKey deserialize(DataInputPlus in, IPartitioner partitioner) throws IOException
{
int len = partitioner.accordFixedLength();
if (len < 0) len = in.readUnsignedVInt32();
TableId tableId = deserializePrefix(in, version);
return deserializeWithPrefix(tableId, len + 2, in, version, partitioner);
TableId tableId = deserializePrefix(in);
return deserializeWithPrefix(tableId, len + 2, in, partitioner);
}
@Override
public void skip(DataInputPlus in, int version) throws IOException
public void skip(DataInputPlus in) throws IOException
{
skip(in, version, getPartitioner());
skip(in, getPartitioner());
}
public void skip(DataInputPlus in, int version, IPartitioner partitioner) throws IOException
public void skip(DataInputPlus in, IPartitioner partitioner) throws IOException
{
int len = partitioner.accordFixedLength();
if (len < 0) len = in.readUnsignedVInt32();
@ -342,13 +353,13 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
}
@Override
public void serializePrefix(Object prefix, DataOutputPlus out, int version) throws IOException
public void serializePrefix(Object prefix, DataOutputPlus out) throws IOException
{
((TableId)prefix).serializeCompactComparable(out);
}
@Override
public void serializeWithoutPrefixOrLength(TokenKey key, DataOutputPlus out, int version) throws IOException
public void serializeWithoutPrefixOrLength(TokenKey key, DataOutputPlus out) throws IOException
{
out.write(key.prefixSentinel());
key.token.getPartitioner().accordSerialize(key.token, out);
@ -377,18 +388,18 @@ public final class TokenKey extends AccordRoutableKey implements RoutingKey, Ran
}
@Override
public TableId deserializePrefix(DataInputPlus in, int version) throws IOException
public TableId deserializePrefix(DataInputPlus in) throws IOException
{
return TableId.deserializeCompactComparable(in);
}
@Override
public TokenKey deserializeWithPrefix(Object tableId, int length, DataInputPlus in, int version) throws IOException
public TokenKey deserializeWithPrefix(Object tableId, int length, DataInputPlus in) throws IOException
{
return deserializeWithPrefix(tableId, length, in, version, getPartitioner());
return deserializeWithPrefix(tableId, length, in, getPartitioner());
}
public TokenKey deserializeWithPrefix(Object tableId, int length, DataInputPlus in, int version, IPartitioner partitioner) throws IOException
public TokenKey deserializeWithPrefix(Object tableId, int length, DataInputPlus in, IPartitioner partitioner) throws IOException
{
byte sentinel = in.readByte();
Token token = partitioner.accordDeserialize(in, length - 2);

2
src/java/org/apache/cassandra/service/accord/interop/AccordInteropApply.java
View File

@ -44,9 +44,9 @@ import accord.topology.Topologies;
import accord.utils.UnhandledEnum;
import org.agrona.collections.Int2ObjectHashMap;
import org.apache.cassandra.db.ConsistencyLevel;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.service.accord.AccordMessageSink.AccordMessageType;
import org.apache.cassandra.service.accord.serializers.ApplySerializers.ApplySerializer;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.txn.AccordUpdate;
import org.apache.cassandra.tcm.ClusterMetadata;

39
src/java/org/apache/cassandra/service/accord/interop/AccordInteropRead.java
View File

@ -51,7 +51,6 @@ import org.apache.cassandra.db.ReadCommandVerbHandler;
import org.apache.cassandra.db.ReadResponse;
import org.apache.cassandra.db.SinglePartitionReadCommand;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.locator.InetAddressAndPort;
@ -61,9 +60,11 @@ import org.apache.cassandra.service.accord.AccordMessageSink.AccordMessageType;
import org.apache.cassandra.service.accord.TokenRange;
import org.apache.cassandra.service.accord.api.TokenKey;
import org.apache.cassandra.service.accord.serializers.CommandSerializers;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.KeySerializers;
import org.apache.cassandra.service.accord.serializers.ReadDataSerializers;
import org.apache.cassandra.service.accord.serializers.ReadDataSerializers.ReadDataSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.service.accord.txn.TxnNamedRead;
import org.apache.cassandra.service.accord.txn.TxnRead;
import org.apache.cassandra.utils.Pair;
@ -79,31 +80,31 @@ public class AccordInteropRead extends ReadData
public static final IVersionedSerializer<AccordInteropRead> requestSerializer = new ReadDataSerializer<AccordInteropRead>()
{
@Override
public void serialize(AccordInteropRead read, DataOutputPlus out, int version) throws IOException
public void serialize(AccordInteropRead read, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(read.txnId, out, version);
KeySerializers.participants.serialize(read.scope, out, version);
CommandSerializers.txnId.serialize(read.txnId, out);
KeySerializers.participants.serialize(read.scope, out);
out.writeUnsignedVInt(read.executeAtEpoch);
ReadCommand.serializer.serialize(read.command, out, version);
ReadCommand.serializer.serialize(read.command, out, version.messageVersion());
}
@Override
public AccordInteropRead deserialize(DataInputPlus in, int version) throws IOException
public AccordInteropRead deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> scope = KeySerializers.participants.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> scope = KeySerializers.participants.deserialize(in);
long executeAtEpoch = in.readUnsignedVInt();
ReadCommand command = ReadCommand.serializer.deserialize(in, version);
ReadCommand command = ReadCommand.serializer.deserialize(in, version.messageVersion());
return new AccordInteropRead(txnId, scope, executeAtEpoch, command);
}
@Override
public long serializedSize(AccordInteropRead read, int version)
public long serializedSize(AccordInteropRead read, Version version)
{
return CommandSerializers.txnId.serializedSize(read.txnId, version)
+ KeySerializers.participants.serializedSize(read.scope, version)
return CommandSerializers.txnId.serializedSize(read.txnId)
+ KeySerializers.participants.serializedSize(read.scope)
+ TypeSizes.sizeofUnsignedVInt(read.executeAtEpoch)
+ ReadCommand.serializer.serializedSize(read.command, version);
+ ReadCommand.serializer.serializedSize(read.command, version.messageVersion());
}
};
@ -116,23 +117,23 @@ public class AccordInteropRead extends ReadData
static final IVersionedSerializer<LocalReadData> serializer = new IVersionedSerializer<>()
{
@Override
public void serialize(LocalReadData data, DataOutputPlus out, int version) throws IOException
public void serialize(LocalReadData data, DataOutputPlus out, Version version) throws IOException
{
data.ensureRemoteResponse();
ReadResponse.serializer.serialize(data.remoteResponse, out, version);
ReadResponse.serializer.serialize(data.remoteResponse, out, version.messageVersion());
}
@Override
public LocalReadData deserialize(DataInputPlus in, int version) throws IOException
public LocalReadData deserialize(DataInputPlus in, Version version) throws IOException
{
return new LocalReadData(ReadResponse.serializer.deserialize(in, version));
return new LocalReadData(ReadResponse.serializer.deserialize(in, version.messageVersion()));
}
@Override
public long serializedSize(LocalReadData data, int version)
public long serializedSize(LocalReadData data, Version version)
{
data.ensureRemoteResponse();
return ReadResponse.serializer.serializedSize(data.remoteResponse, version);
return ReadResponse.serializer.serializedSize(data.remoteResponse, version.messageVersion());
}
};

33
src/java/org/apache/cassandra/service/accord/interop/AccordInteropReadRepair.java
View File

@ -38,7 +38,6 @@ import accord.utils.async.AsyncChains;
import org.apache.cassandra.db.Mutation;
import org.apache.cassandra.db.ReadRepairVerbHandler;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.locator.InetAddressAndPort;
@ -48,9 +47,11 @@ import org.apache.cassandra.net.RequestCallback;
import org.apache.cassandra.net.Verb;
import org.apache.cassandra.service.accord.AccordMessageSink.AccordMessageType;
import org.apache.cassandra.service.accord.serializers.CommandSerializers;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.KeySerializers;
import org.apache.cassandra.service.accord.serializers.ReadDataSerializers;
import org.apache.cassandra.service.accord.serializers.ReadDataSerializers.ReadDataSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
/**
* Applies a read repair mutation from inside the context of a CommandStore via AbstractExecute
@ -62,31 +63,31 @@ public class AccordInteropReadRepair extends ReadData
public static final IVersionedSerializer<AccordInteropReadRepair> requestSerializer = new ReadDataSerializer<AccordInteropReadRepair>()
{
@Override
public void serialize(AccordInteropReadRepair repair, DataOutputPlus out, int version) throws IOException
public void serialize(AccordInteropReadRepair repair, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(repair.txnId, out, version);
KeySerializers.participants.serialize(repair.scope, out, version);
CommandSerializers.txnId.serialize(repair.txnId, out);
KeySerializers.participants.serialize(repair.scope, out);
out.writeUnsignedVInt(repair.executeAtEpoch);
Mutation.serializer.serialize(repair.mutation, out, version);
Mutation.serializer.serialize(repair.mutation, out, version.messageVersion());
}
@Override
public AccordInteropReadRepair deserialize(DataInputPlus in, int version) throws IOException
public AccordInteropReadRepair deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> scope = KeySerializers.participants.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> scope = KeySerializers.participants.deserialize(in);
long executeAtEpoch = in.readUnsignedVInt();
Mutation mutation = Mutation.serializer.deserialize(in, version);
Mutation mutation = Mutation.serializer.deserialize(in, version.messageVersion());
return new AccordInteropReadRepair(txnId, scope, executeAtEpoch, mutation);
}
@Override
public long serializedSize(AccordInteropReadRepair repair, int version)
public long serializedSize(AccordInteropReadRepair repair, Version version)
{
return CommandSerializers.txnId.serializedSize(repair.txnId, version)
+ KeySerializers.participants.serializedSize(repair.scope, version)
return CommandSerializers.txnId.serializedSize(repair.txnId)
+ KeySerializers.participants.serializedSize(repair.scope)
+ TypeSizes.sizeofUnsignedVInt(repair.executeAtEpoch)
+ Mutation.serializer.serializedSize(repair.mutation, version);
+ Mutation.serializer.serializedSize(repair.mutation, version.messageVersion());
}
};
@ -111,11 +112,11 @@ public class AccordInteropReadRepair extends ReadData
private static final IVersionedSerializer<Data> noop_data_serializer = new IVersionedSerializer<>()
{
@Override
public void serialize(Data t, DataOutputPlus out, int version) throws IOException {}
public void serialize(Data t, DataOutputPlus out, Version version) throws IOException {}
@Override
public Data deserialize(DataInputPlus in, int version) throws IOException { return Data.NOOP_DATA; }
public Data deserialize(DataInputPlus in, Version version) throws IOException { return Data.NOOP_DATA; }
public long serializedSize(Data t, int version) { return 0; }
public long serializedSize(Data t, Version version) { return 0; }
};
public static final IVersionedSerializer<ReadReply> replySerializer = new ReadDataSerializers.ReplySerializer<>(noop_data_serializer);

45
src/java/org/apache/cassandra/service/accord/interop/AccordInteropStableThenRead.java
View File

@ -41,7 +41,6 @@ import accord.primitives.TxnId;
import accord.topology.Topologies;
import org.apache.cassandra.db.ReadCommand;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.AccordMessageSink.AccordMessageType;
@ -49,8 +48,10 @@ import org.apache.cassandra.service.accord.serializers.CommandSerializers;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
import org.apache.cassandra.service.accord.serializers.CommitSerializers;
import org.apache.cassandra.service.accord.serializers.DepsSerializers;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.KeySerializers;
import org.apache.cassandra.service.accord.serializers.ReadDataSerializers.ReadDataSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import static accord.messages.Commit.WithDeps.HasDeps;
import static accord.messages.Commit.WithDeps.NoDeps;
@ -65,49 +66,49 @@ public class AccordInteropStableThenRead extends AccordInteropRead
public static final IVersionedSerializer<AccordInteropStableThenRead> requestSerializer = new ReadDataSerializer<>()
{
@Override
public void serialize(AccordInteropStableThenRead read, DataOutputPlus out, int version) throws IOException
public void serialize(AccordInteropStableThenRead read, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(read.txnId, out, version);
KeySerializers.participants.serialize(read.scope, out, version);
CommitSerializers.kind.serialize(read.kind, out, version);
CommandSerializers.txnId.serialize(read.txnId, out);
KeySerializers.participants.serialize(read.scope, out);
CommitSerializers.kind.serialize(read.kind, out);
out.writeUnsignedVInt(read.minEpoch);
ExecuteAtSerializer.serialize(read.txnId, read.executeAt, out);
if (read.kind.withTxn != NoTxn)
CommandSerializers.nullablePartialTxn.serialize(read.partialTxn, out, version);
if (read.kind.withDeps == HasDeps)
DepsSerializers.partialDeps.serialize(read.partialDeps, out, version);
DepsSerializers.partialDeps.serialize(read.partialDeps, out);
if (read.kind.withTxn == HasTxn)
KeySerializers.fullRoute.serialize(read.route, out, version);
ReadCommand.serializer.serialize(read.command, out, version);
KeySerializers.fullRoute.serialize(read.route, out);
ReadCommand.serializer.serialize(read.command, out, version.messageVersion());
}
@Override
public AccordInteropStableThenRead deserialize(DataInputPlus in, int version) throws IOException
public AccordInteropStableThenRead deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> scope = KeySerializers.participants.deserialize(in, version);
Commit.Kind kind = CommitSerializers.kind.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> scope = KeySerializers.participants.deserialize(in);
Commit.Kind kind = CommitSerializers.kind.deserialize(in);
long minEpoch = in.readUnsignedVInt();
Timestamp executeAt = ExecuteAtSerializer.deserialize(txnId, in);
PartialTxn partialTxn = kind.withTxn == NoTxn ? null : CommandSerializers.nullablePartialTxn.deserialize(in, version);
PartialDeps partialDeps = kind.withDeps == NoDeps ? null : DepsSerializers.partialDeps.deserialize(in, version);
FullRoute < ?> route = kind.withTxn == HasTxn ? KeySerializers.fullRoute.deserialize(in, version) : null;
ReadCommand command = ReadCommand.serializer.deserialize(in, version);
PartialDeps partialDeps = kind.withDeps == NoDeps ? null : DepsSerializers.partialDeps.deserialize(in);
FullRoute < ?> route = kind.withTxn == HasTxn ? KeySerializers.fullRoute.deserialize(in) : null;
ReadCommand command = ReadCommand.serializer.deserialize(in, version.messageVersion());
return new AccordInteropStableThenRead(txnId, scope, kind, minEpoch, executeAt, partialTxn, partialDeps, route, command);
}
@Override
public long serializedSize(AccordInteropStableThenRead read, int version)
public long serializedSize(AccordInteropStableThenRead read, Version version)
{
return CommandSerializers.txnId.serializedSize(read.txnId, version)
+ KeySerializers.participants.serializedSize(read.scope, version)
+ CommitSerializers.kind.serializedSize(read.kind, version)
return CommandSerializers.txnId.serializedSize(read.txnId)
+ KeySerializers.participants.serializedSize(read.scope)
+ CommitSerializers.kind.serializedSize(read.kind)
+ TypeSizes.sizeofUnsignedVInt(read.minEpoch)
+ ExecuteAtSerializer.serializedSize(read.txnId, read.executeAt)
+ (read.kind.withTxn == NoTxn ? 0 : CommandSerializers.nullablePartialTxn.serializedSize(read.partialTxn, version))
+ (read.kind.withDeps != HasDeps ? 0 : DepsSerializers.partialDeps.serializedSize(read.partialDeps, version))
+ (read.kind.withTxn != HasTxn ? 0 : KeySerializers.fullRoute.serializedSize(read.route, version))
+ ReadCommand.serializer.serializedSize(read.command, version);
+ (read.kind.withDeps != HasDeps ? 0 : DepsSerializers.partialDeps.serializedSize(read.partialDeps))
+ (read.kind.withTxn != HasTxn ? 0 : KeySerializers.fullRoute.serializedSize(read.route))
+ ReadCommand.serializer.serializedSize(read.command, version.messageVersion());
}
};

147
src/java/org/apache/cassandra/service/accord/journal/AccordTopologyUpdate.java
View File

@ -22,6 +22,7 @@ import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Objects;
import java.util.TreeMap;
import java.util.function.Function;
@ -34,7 +35,7 @@ import accord.utils.Invariants;
import accord.utils.UnhandledEnum;
import org.agrona.collections.Int2ObjectHashMap;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.AccordConfigurationService;
@ -42,6 +43,7 @@ import org.apache.cassandra.service.accord.AccordJournalValueSerializers;
import org.apache.cassandra.service.accord.JournalKey;
import org.apache.cassandra.service.accord.serializers.KeySerializers;
import org.apache.cassandra.service.accord.serializers.TopologySerializers;
import org.apache.cassandra.service.accord.serializers.Version;
import static org.apache.cassandra.service.accord.JournalKey.Type.TOPOLOGY_UPDATE;
@ -55,29 +57,23 @@ public interface AccordTopologyUpdate
{
return new NewTopology(update);
}
class RangesForEpochSerializer implements IVersionedSerializer<CommandStores.RangesForEpoch>
class RangesForEpochSerializer implements UnversionedSerializer<CommandStores.RangesForEpoch>
{
public static final RangesForEpochSerializer instance = new RangesForEpochSerializer();
@Override
public void serialize(CommandStores.RangesForEpoch from, DataOutputPlus out, int version) throws IOException
public void serialize(CommandStores.RangesForEpoch from, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(from.size());
from.forEach((epoch, ranges) -> {
try
{
out.writeLong(epoch);
KeySerializers.ranges.serialize(ranges, out, version);
}
catch (Throwable t)
{
throw new IllegalStateException("Serialization error", t);
}
});
for (int i = 0; i < from.size(); i++)
{
out.writeLong(from.epochAtIndex(i));
KeySerializers.ranges.serialize(from.rangesAtIndex(i), out);
}
}
@Override
public CommandStores.RangesForEpoch deserialize(DataInputPlus in, int version) throws IOException
public CommandStores.RangesForEpoch deserialize(DataInputPlus in) throws IOException
{
int size = in.readUnsignedVInt32();
Ranges[] ranges = new Ranges[size];
@ -85,120 +81,130 @@ public interface AccordTopologyUpdate
for (int i = 0; i < ranges.length; i++)
{
epochs[i] = in.readLong();
ranges[i] = KeySerializers.ranges.deserialize(in, version);
ranges[i] = KeySerializers.ranges.deserialize(in);
}
Invariants.require(ranges.length == epochs.length);
return new CommandStores.RangesForEpoch(epochs, ranges);
}
@Override
public long serializedSize(CommandStores.RangesForEpoch t, int version)
public long serializedSize(CommandStores.RangesForEpoch from)
{
return TypeSizes.sizeofUnsignedVInt(t.size());
long size = TypeSizes.sizeofUnsignedVInt(from.size());
for (int i = 0; i < from.size(); i++)
{
size += TypeSizes.sizeof(from.epochAtIndex(i));
size += KeySerializers.ranges.serializedSize(from.rangesAtIndex(i));
}
return size;
}
}
class TopologyUpdateSerializer implements IVersionedSerializer<Journal.TopologyUpdate>
class TopologyUpdateSerializer implements UnversionedSerializer<Journal.TopologyUpdate>
{
public static final TopologyUpdateSerializer instance = new TopologyUpdateSerializer();
@Override
public void serialize(Journal.TopologyUpdate from, DataOutputPlus out, int version) throws IOException
public void serialize(Journal.TopologyUpdate from, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(from.commandStores.size());
for (Map.Entry<Integer, CommandStores.RangesForEpoch> e : from.commandStores.entrySet())
{
out.writeUnsignedVInt32(e.getKey());
RangesForEpochSerializer.instance.serialize(e.getValue(), out, version);
RangesForEpochSerializer.instance.serialize(e.getValue(), out);
}
TopologySerializers.topology.serialize(from.local, out, version);
TopologySerializers.topology.serialize(from.global, out, version);
//TODO (performance): local to what? Rather than serializing local we can serialize the node its relative too? that why when we deserialize we do globa.forNode(node)
// this also decreases the size as we don't have redundent shards
TopologySerializers.topology.serialize(from.local, out);
TopologySerializers.topology.serialize(from.global, out);
}
@Override
public Journal.TopologyUpdate deserialize(DataInputPlus in, int version) throws IOException
public Journal.TopologyUpdate deserialize(DataInputPlus in) throws IOException
{
int commandStoresSize = in.readUnsignedVInt32();
Int2ObjectHashMap<CommandStores.RangesForEpoch> commandStores = new Int2ObjectHashMap<>();
for (int j = 0; j < commandStoresSize; j++)
{
int commandStoreId = in.readUnsignedVInt32();
CommandStores.RangesForEpoch rangesForEpoch = RangesForEpochSerializer.instance.deserialize(in, version);
CommandStores.RangesForEpoch rangesForEpoch = RangesForEpochSerializer.instance.deserialize(in);
commandStores.put(commandStoreId, rangesForEpoch);
}
Topology local = TopologySerializers.topology.deserialize(in, version);
Topology global = TopologySerializers.topology.deserialize(in, version);
Topology local = TopologySerializers.topology.deserialize(in);
Topology global = TopologySerializers.topology.deserialize(in);
return new Journal.TopologyUpdate(commandStores, local, global);
}
@Override
public long serializedSize(Journal.TopologyUpdate from, int version)
public long serializedSize(Journal.TopologyUpdate from)
{
long size = TypeSizes.sizeofUnsignedVInt(from.commandStores.size());
for (Map.Entry<Integer, CommandStores.RangesForEpoch> e : from.commandStores.entrySet())
{
size += TypeSizes.sizeofUnsignedVInt(e.getKey());
size += RangesForEpochSerializer.instance.serializedSize(e.getValue(), version);
size += RangesForEpochSerializer.instance.serializedSize(e.getValue());
}
size += TopologySerializers.topology.serializedSize(from.local, version);
size += TopologySerializers.topology.serializedSize(from.global, version);
size += TopologySerializers.topology.serializedSize(from.local);
size += TopologySerializers.topology.serializedSize(from.global);
return size;
}
}
class Serializer implements IVersionedSerializer<AccordTopologyUpdate>
class Serializer implements UnversionedSerializer<AccordTopologyUpdate>
{
public static Serializer instance = new Serializer();
public void serialize(AccordTopologyUpdate t, DataOutputPlus out, int version) throws IOException
@Override
public void serialize(AccordTopologyUpdate t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt(t.epoch());
out.writeUnsignedVInt32(t.kind().ordinal());
switch (t.kind())
{
case NewTopology:
TopologyUpdateSerializer.instance.serialize(((NewTopology) t).update, out, version);
TopologyUpdateSerializer.instance.serialize(((NewTopology) t).update, out);
break;
case Topologies:
TopologyImage image = (TopologyImage) t;
out.writeBoolean(image.update != null);
if (image.update != null)
TopologyUpdateSerializer.instance.serialize(image.update, out, version);
TopologyUpdateSerializer.instance.serialize(image.update, out);
if (image.syncStatus == null)
out.writeByte(Byte.MAX_VALUE);
else
out.writeByte(image.syncStatus.ordinal());
KeySerializers.ranges.serialize(image.closed, out, version);
KeySerializers.ranges.serialize(image.retired, out, version);
KeySerializers.ranges.serialize(image.closed, out);
KeySerializers.ranges.serialize(image.retired, out);
break;
default:
throw new UnhandledEnum(t.kind());
}
}
public AccordTopologyUpdate deserialize(DataInputPlus in, int version) throws IOException
@Override
public AccordTopologyUpdate deserialize(DataInputPlus in) throws IOException
{
int epoch = in.readUnsignedVInt32();
long epoch = in.readUnsignedVInt();
Kind kind = Kind.values()[in.readUnsignedVInt32()];
switch (kind)
{
case NewTopology:
return new NewTopology(TopologyUpdateSerializer.instance.deserialize(in, version));
return new NewTopology(TopologyUpdateSerializer.instance.deserialize(in));
case Topologies:
{
TopologyImage image = new TopologyImage(epoch);
if (in.readBoolean())
image.update = TopologyUpdateSerializer.instance.deserialize(in, version);
image.update = TopologyUpdateSerializer.instance.deserialize(in);
byte syncStateByte = in.readByte();
if (syncStateByte != Byte.MAX_VALUE)
image.syncStatus = AccordConfigurationService.SyncStatus.values()[syncStateByte];
image.closed = KeySerializers.ranges.deserialize(in, version);
image.retired = KeySerializers.ranges.deserialize(in, version);
image.closed = KeySerializers.ranges.deserialize(in);
image.retired = KeySerializers.ranges.deserialize(in);
return image;
}
default:
@ -206,7 +212,8 @@ public interface AccordTopologyUpdate
}
}
public long serializedSize(AccordTopologyUpdate t, int version)
@Override
public long serializedSize(AccordTopologyUpdate t)
{
long size = TypeSizes.sizeofUnsignedVInt(t.epoch());
size += TypeSizes.sizeofUnsignedVInt(t.kind().ordinal());
@ -214,19 +221,19 @@ public interface AccordTopologyUpdate
switch (t.kind())
{
case NewTopology:
size += TopologyUpdateSerializer.instance.serializedSize(((NewTopology) t).update, version);
size += TopologyUpdateSerializer.instance.serializedSize(((NewTopology) t).update);
break;
case Topologies:
TopologyImage image = (TopologyImage) t;
size += TypeSizes.sizeof(image.update != null);
if (image.update != null)
size += TopologyUpdateSerializer.instance.serializedSize(image.update, version);
size += TopologyUpdateSerializer.instance.serializedSize(image.update);
size += Byte.BYTES;
size += KeySerializers.ranges.serializedSize(image.closed, version);
size += KeySerializers.ranges.serializedSize(image.retired, version);
size += KeySerializers.ranges.serializedSize(image.closed);
size += KeySerializers.ranges.serializedSize(image.retired);
break;
default:
throw new UnhandledEnum(t.kind());
@ -288,11 +295,26 @@ public interface AccordTopologyUpdate
accumulator.closed = accumulator.closed.with(closed);
accumulator.retired = accumulator.retired.with(retired);
}
@Override
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TopologyImage that = (TopologyImage) o;
return epoch == that.epoch && Objects.equals(update, that.update) && syncStatus == that.syncStatus && closed.equals(that.closed) && retired.equals(that.retired);
}
@Override
public int hashCode()
{
return Objects.hash(update, syncStatus, closed, retired, epoch);
}
}
class NewTopology implements AccordTopologyUpdate
{
private final Journal.TopologyUpdate update;
public final Journal.TopologyUpdate update;
private final long epoch;
public NewTopology(Journal.TopologyUpdate update)
@ -320,6 +342,21 @@ public interface AccordTopologyUpdate
Invariants.require(accumulator.update == null);
accumulator.update = update;
}
@Override
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
NewTopology that = (NewTopology) o;
return epoch == that.epoch && update.equals(that.update);
}
@Override
public int hashCode()
{
return Objects.hash(update, epoch);
}
}
class Accumulator
@ -384,28 +421,28 @@ public interface AccordTopologyUpdate
}
@Override
public void serialize(JournalKey key, AccordTopologyUpdate from, DataOutputPlus out, int version) throws IOException
public void serialize(JournalKey key, AccordTopologyUpdate from, DataOutputPlus out, Version version) throws IOException
{
out.writeUnsignedVInt32(1);
Serializer.instance.serialize(from, out, version);
Serializer.instance.serialize(from, out);
}
@Override
public void reserialize(JournalKey key, Accumulator from, DataOutputPlus out, int version) throws IOException
public void reserialize(JournalKey key, Accumulator from, DataOutputPlus out, Version version) throws IOException
{
out.writeUnsignedVInt32(from.get().size());
for (TopologyImage value : from.get().values())
Serializer.instance.serialize(value, out, version);
Serializer.instance.serialize(value, out);
}
@Override
public void deserialize(JournalKey key, Accumulator into, DataInputPlus in, int version) throws IOException
public void deserialize(JournalKey key, Accumulator into, DataInputPlus in, Version version) throws IOException
{
long minEpoch = this.minEpoch.epoch();
int count = in.readUnsignedVInt32();
while (--count >= 0)
{
AccordTopologyUpdate update = Serializer.instance.deserialize(in, version);
AccordTopologyUpdate update = Serializer.instance.deserialize(in);
if (update.epoch() >= minEpoch)
into.update(update);
else

84
src/java/org/apache/cassandra/service/accord/serializers/AcceptSerializers.java
View File

@ -31,7 +31,7 @@ import accord.primitives.Route;
import accord.primitives.Timestamp;
import accord.primitives.TxnId;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
@ -49,69 +49,69 @@ public class AcceptSerializers
private static final int IS_PARTIAL = 1;
@Override
public void serializeBody(Accept accept, DataOutputPlus out, int version) throws IOException
public void serializeBody(Accept accept, DataOutputPlus out, Version version) throws IOException
{
out.writeByte((accept.kind.ordinal() << 1) | (accept.isPartialAccept ? IS_PARTIAL : 0));
CommandSerializers.ballot.serialize(accept.ballot, out, version);
CommandSerializers.ballot.serialize(accept.ballot, out);
ExecuteAtSerializer.serialize(accept.txnId, accept.executeAt, out);
DepsSerializers.partialDeps.serialize(accept.partialDeps, out, version);
DepsSerializers.partialDeps.serialize(accept.partialDeps, out);
}
@Override
public Accept deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
public Accept deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
{
int flags = in.readByte();
Accept.Kind kind = kinds[(flags >>> 1) & 1];
return create(txnId, scope, waitForEpoch, minEpoch,
kind,
CommandSerializers.ballot.deserialize(in, version),
CommandSerializers.ballot.deserialize(in),
ExecuteAtSerializer.deserialize(txnId, in),
DepsSerializers.partialDeps.deserialize(in, version),
DepsSerializers.partialDeps.deserialize(in),
(flags & IS_PARTIAL) != 0);
}
@Override
public long serializedBodySize(Accept accept, int version)
public long serializedBodySize(Accept accept, Version version)
{
return 1
+ CommandSerializers.ballot.serializedSize(accept.ballot, version)
+ CommandSerializers.ballot.serializedSize(accept.ballot)
+ ExecuteAtSerializer.serializedSize(accept.txnId, accept.executeAt)
+ DepsSerializers.partialDeps.serializedSize(accept.partialDeps, version);
+ DepsSerializers.partialDeps.serializedSize(accept.partialDeps);
}
};
}
public static final IVersionedSerializer<Accept.NotAccept> notAccept = new IVersionedSerializer<>()
public static final UnversionedSerializer<Accept.NotAccept> notAccept = new UnversionedSerializer<>()
{
@Override
public void serialize(Accept.NotAccept invalidate, DataOutputPlus out, int version) throws IOException
public void serialize(Accept.NotAccept invalidate, DataOutputPlus out) throws IOException
{
CommandSerializers.status.serialize(invalidate.status, out, version);
CommandSerializers.ballot.serialize(invalidate.ballot, out, version);
CommandSerializers.txnId.serialize(invalidate.txnId, out, version);
KeySerializers.participants.serialize(invalidate.participants, out, version);
CommandSerializers.status.serialize(invalidate.status, out);
CommandSerializers.ballot.serialize(invalidate.ballot, out);
CommandSerializers.txnId.serialize(invalidate.txnId, out);
KeySerializers.participants.serialize(invalidate.participants, out);
}
@Override
public Accept.NotAccept deserialize(DataInputPlus in, int version) throws IOException
public Accept.NotAccept deserialize(DataInputPlus in) throws IOException
{
return new Accept.NotAccept(CommandSerializers.status.deserialize(in, version),
CommandSerializers.ballot.deserialize(in, version),
CommandSerializers.txnId.deserialize(in, version),
KeySerializers.participants.deserialize(in, version));
return new Accept.NotAccept(CommandSerializers.status.deserialize(in),
CommandSerializers.ballot.deserialize(in),
CommandSerializers.txnId.deserialize(in),
KeySerializers.participants.deserialize(in));
}
@Override
public long serializedSize(Accept.NotAccept invalidate, int version)
public long serializedSize(Accept.NotAccept invalidate)
{
return CommandSerializers.status.serializedSize(invalidate.status, version)
+ CommandSerializers.ballot.serializedSize(invalidate.ballot, version)
+ CommandSerializers.txnId.serializedSize(invalidate.txnId, version)
+ KeySerializers.participants.serializedSize(invalidate.participants, version);
return CommandSerializers.status.serializedSize(invalidate.status)
+ CommandSerializers.ballot.serializedSize(invalidate.ballot)
+ CommandSerializers.txnId.serializedSize(invalidate.txnId)
+ KeySerializers.participants.serializedSize(invalidate.participants);
}
};
public static final IVersionedSerializer<AcceptReply> reply = new ReplySerializer();
public static class ReplySerializer implements IVersionedSerializer<AcceptReply>
public static final UnversionedSerializer<AcceptReply> reply = new ReplySerializer();
public static class ReplySerializer implements UnversionedSerializer<AcceptReply>
{
// we have one spare bit at 0x04 for either another flag or more AcceptOutcome variants
private static final int SUPERSEDED_BY = 0x08;
@ -120,7 +120,7 @@ public class AcceptSerializers
private static final int DEPS = 0x40;
private static final int FLAGS = 0x80;
@Override
public void serialize(AcceptReply reply, DataOutputPlus out, int version) throws IOException
public void serialize(AcceptReply reply, DataOutputPlus out) throws IOException
{
int flags = reply.outcome.ordinal()
| (reply.supersededBy != null ? SUPERSEDED_BY : 0)
@ -131,46 +131,46 @@ public class AcceptSerializers
out.writeByte(flags);
if (reply.supersededBy != null)
CommandSerializers.ballot.serialize(reply.supersededBy, out, version);
CommandSerializers.ballot.serialize(reply.supersededBy, out);
if (reply.committedExecuteAt != null)
ExecuteAtSerializer.serialize(reply.committedExecuteAt, out);
if (reply.successful != null)
KeySerializers.participants.serialize(reply.successful, out, version);
KeySerializers.participants.serialize(reply.successful, out);
if (reply.deps != null)
DepsSerializers.deps.serialize(reply.deps, out, version);
DepsSerializers.deps.serialize(reply.deps, out);
if (!reply.flags.isEmpty())
out.writeUnsignedVInt32(reply.flags.bits());
}
private final AcceptOutcome[] outcomes = AcceptOutcome.values();
@Override
public AcceptReply deserialize(DataInputPlus in, int version) throws IOException
public AcceptReply deserialize(DataInputPlus in) throws IOException
{
int flags = in.readByte();
AcceptOutcome outcome = outcomes[flags & 3];
Ballot supersededBy = (flags & SUPERSEDED_BY) == 0 ? null : CommandSerializers.ballot.deserialize(in, version);
Ballot supersededBy = (flags & SUPERSEDED_BY) == 0 ? null : CommandSerializers.ballot.deserialize(in);
Timestamp committedExecuteAt = (flags & COMMITTED_EXECUTE_AT) == 0 ? null : ExecuteAtSerializer.deserialize(in);
Participants<?> successful = (flags & SUCCESSFUL) == 0 ? null : KeySerializers.participants.deserialize(in, version);
Deps deps = (flags & DEPS) == 0 ? null : DepsSerializers.deps.deserialize(in, version);
Participants<?> successful = (flags & SUCCESSFUL) == 0 ? null : KeySerializers.participants.deserialize(in);
Deps deps = (flags & DEPS) == 0 ? null : DepsSerializers.deps.deserialize(in);
ExecuteFlags executeFlags = (flags & FLAGS) == 0 ? ExecuteFlags.none() : ExecuteFlags.get(in.readUnsignedVInt32());
return new AcceptReply(outcome, supersededBy, successful, deps, committedExecuteAt, executeFlags);
}
@Override
public long serializedSize(AcceptReply reply, int version)
public long serializedSize(AcceptReply reply)
{
long size = TypeSizes.BYTE_SIZE;
if (reply.supersededBy != null)
size += CommandSerializers.ballot.serializedSize(reply.supersededBy, version);
size += CommandSerializers.ballot.serializedSize(reply.supersededBy);
if (reply.committedExecuteAt != null)
size += ExecuteAtSerializer.serializedSize(reply.committedExecuteAt);
if (reply.successful != null)
size += KeySerializers.participants.serializedSize(reply.successful, version);
size += KeySerializers.participants.serializedSize(reply.successful);
if (reply.deps != null)
size += DepsSerializers.deps.serializedSize(reply.deps, version);
size += DepsSerializers.deps.serializedSize(reply.deps);
if (!reply.flags.isEmpty())
size += TypeSizes.sizeofUnsignedVInt(reply.flags.bits());
return size;
}
};
}
}

42
src/java/org/apache/cassandra/service/accord/serializers/ApplySerializers.java
View File

@ -31,7 +31,7 @@ import accord.primitives.TxnId;
import accord.primitives.Writes;
import accord.utils.Invariants;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
@ -41,20 +41,20 @@ import static accord.primitives.Txn.Kind.Write;
public class ApplySerializers
{
private static final IVersionedSerializer<Apply.Kind> kind = new IVersionedSerializer<>()
private static final UnversionedSerializer<Apply.Kind> kind = new UnversionedSerializer<>()
{
public void serialize(Apply.Kind kind, DataOutputPlus out, int version) throws IOException
public void serialize(Apply.Kind kind, DataOutputPlus out) throws IOException
{
Invariants.requireArgument(kind == Apply.Kind.Maximal || kind == Apply.Kind.Minimal);
out.writeBoolean(kind == Apply.Kind.Maximal);
}
public Apply.Kind deserialize(DataInputPlus in, int version) throws IOException
public Apply.Kind deserialize(DataInputPlus in) throws IOException
{
return in.readBoolean() ? Apply.Kind.Maximal : Apply.Kind.Minimal;
}
public long serializedSize(Apply.Kind t, int version)
public long serializedSize(Apply.Kind t)
{
return TypeSizes.BOOL_SIZE;
}
@ -63,14 +63,14 @@ public class ApplySerializers
public abstract static class ApplySerializer<A extends Apply> extends TxnRequestSerializer<A>
{
@Override
public void serializeBody(A apply, DataOutputPlus out, int version) throws IOException
public void serializeBody(A apply, DataOutputPlus out, Version version) throws IOException
{
out.writeVInt(apply.minEpoch - apply.waitForEpoch);
kind.serialize(apply.kind, out, version);
kind.serialize(apply.kind, out);
ExecuteAtSerializer.serialize(apply.txnId, apply.executeAt, out);
DepsSerializers.partialDeps.serialize(apply.deps, out, version);
DepsSerializers.partialDeps.serialize(apply.deps, out);
CommandSerializers.nullablePartialTxn.serialize(apply.txn, out, version);
KeySerializers.nullableFullRoute.serialize(apply.fullRoute, out, version);
KeySerializers.nullableFullRoute.serialize(apply.fullRoute, out);
if (apply.txnId.is(Write))
CommandSerializers.writes.serialize(apply.writes, out, version);
}
@ -79,27 +79,27 @@ public class ApplySerializers
Timestamp executeAt, PartialDeps deps, PartialTxn txn, FullRoute<?> fullRoute, Writes writes, Result result);
@Override
public A deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch) throws IOException
public A deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch) throws IOException
{
return deserializeApply(txnId, scope, waitForEpoch + in.readVInt(), waitForEpoch,
kind.deserialize(in, version),
kind.deserialize(in),
ExecuteAtSerializer.deserialize(txnId, in),
DepsSerializers.partialDeps.deserialize(in, version),
DepsSerializers.partialDeps.deserialize(in),
CommandSerializers.nullablePartialTxn.deserialize(in, version),
KeySerializers.nullableFullRoute.deserialize(in, version),
KeySerializers.nullableFullRoute.deserialize(in),
(txnId.is(Write) ? CommandSerializers.writes.deserialize(in, version) : null),
ResultSerializers.APPLIED);
}
@Override
public long serializedBodySize(A apply, int version)
public long serializedBodySize(A apply, Version version)
{
return TypeSizes.sizeofVInt(apply.minEpoch - apply.waitForEpoch)
+ kind.serializedSize(apply.kind, version)
+ kind.serializedSize(apply.kind)
+ ExecuteAtSerializer.serializedSize(apply.txnId, apply.executeAt)
+ DepsSerializers.partialDeps.serializedSize(apply.deps, version)
+ DepsSerializers.partialDeps.serializedSize(apply.deps)
+ CommandSerializers.nullablePartialTxn.serializedSize(apply.txn, version)
+ KeySerializers.nullableFullRoute.serializedSize(apply.fullRoute, version)
+ KeySerializers.nullableFullRoute.serializedSize(apply.fullRoute)
+ (apply.txnId.is(Write) ? CommandSerializers.writes.serializedSize(apply.writes, version) : 0);
}
}
@ -114,24 +114,24 @@ public class ApplySerializers
}
};
public static final IVersionedSerializer<Apply.ApplyReply> reply = new IVersionedSerializer<>()
public static final UnversionedSerializer<Apply.ApplyReply> reply = new UnversionedSerializer<>()
{
private final Apply.ApplyReply[] replies = Apply.ApplyReply.values();
@Override
public void serialize(Apply.ApplyReply t, DataOutputPlus out, int version) throws IOException
public void serialize(Apply.ApplyReply t, DataOutputPlus out) throws IOException
{
out.writeByte(t.ordinal());
}
@Override
public Apply.ApplyReply deserialize(DataInputPlus in, int version) throws IOException
public Apply.ApplyReply deserialize(DataInputPlus in) throws IOException
{
return replies[in.readByte()];
}
@Override
public long serializedSize(Apply.ApplyReply t, int version)
public long serializedSize(Apply.ApplyReply t)
{
return 1;
}

23
src/java/org/apache/cassandra/service/accord/serializers/AsymmetricVersionedSerializer.java Normal file
View File

@ -0,0 +1,23 @@
/*
* 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.apache.cassandra.service.accord.serializers;
public interface AsymmetricVersionedSerializer<In, Out> extends org.apache.cassandra.io.AsymmetricVersionedSerializer<In, Out, Version>
{
}

72
src/java/org/apache/cassandra/service/accord/serializers/AwaitSerializers.java
View File

@ -32,54 +32,54 @@ import accord.primitives.SaveStatus;
import accord.primitives.TxnId;
import accord.utils.Invariants;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.utils.vint.VIntCoding;
public class AwaitSerializers
{
public static final IVersionedSerializer<Await> request = new RequestSerializer<>()
public static final UnversionedSerializer<Await> request = new RequestSerializer<>()
{
@Override
public Await deserialize(TxnId txnId, Participants<?> scope, BlockedUntil blockedUntil, boolean notifyProgressLog, long minAwaitEpoch, long maxAwaitEpoch, int callbackId, DataInputPlus in, int version)
public Await deserialize(TxnId txnId, Participants<?> scope, BlockedUntil blockedUntil, boolean notifyProgressLog, long minAwaitEpoch, long maxAwaitEpoch, int callbackId, DataInputPlus in)
{
return Await.SerializerSupport.create(txnId, scope, blockedUntil, notifyProgressLog, minAwaitEpoch, maxAwaitEpoch, callbackId);
}
};
public static final IVersionedSerializer<RecoverAwait> recoverRequest = new RequestSerializer<>()
public static final UnversionedSerializer<RecoverAwait> recoverRequest = new RequestSerializer<>()
{
@Override
public RecoverAwait deserialize(TxnId txnId, Participants<?> scope, BlockedUntil blockedUntil, boolean notifyProgressLog, long minAwaitEpoch, long maxAwaitEpoch, int callbackId, DataInputPlus in, int version) throws IOException
public RecoverAwait deserialize(TxnId txnId, Participants<?> scope, BlockedUntil blockedUntil, boolean notifyProgressLog, long minAwaitEpoch, long maxAwaitEpoch, int callbackId, DataInputPlus in) throws IOException
{
TxnId recoverId = CommandSerializers.txnId.deserialize(in, version);
TxnId recoverId = CommandSerializers.txnId.deserialize(in);
return RecoverAwait.SerializerSupport.create(txnId, scope, blockedUntil, notifyProgressLog, minAwaitEpoch, maxAwaitEpoch, callbackId, recoverId);
}
@Override
public void serialize(RecoverAwait await, DataOutputPlus out, int version) throws IOException
public void serialize(RecoverAwait await, DataOutputPlus out) throws IOException
{
super.serialize(await, out, version);
CommandSerializers.txnId.serialize(await.recoverId, out, version);
super.serialize(await, out);
CommandSerializers.txnId.serialize(await.recoverId, out);
}
@Override
public long serializedSize(RecoverAwait await, int version)
public long serializedSize(RecoverAwait await)
{
return super.serializedSize(await, version) + CommandSerializers.txnId.serializedSize(await.recoverId, version);
return super.serializedSize(await) + CommandSerializers.txnId.serializedSize(await.recoverId);
}
};
static abstract class RequestSerializer<A extends Await> implements IVersionedSerializer<A>
static abstract class RequestSerializer<A extends Await> implements UnversionedSerializer<A>
{
abstract A deserialize(TxnId txnId, Participants<?> scope, BlockedUntil blockedUntil, boolean notifyProgressLog, long minAwaitEpoch, long maxAwaitEpoch, int callbackId, DataInputPlus in, int version) throws IOException;
abstract A deserialize(TxnId txnId, Participants<?> scope, BlockedUntil blockedUntil, boolean notifyProgressLog, long minAwaitEpoch, long maxAwaitEpoch, int callbackId, DataInputPlus in) throws IOException;
@Override
public void serialize(A await, DataOutputPlus out, int version) throws IOException
public void serialize(A await, DataOutputPlus out) throws IOException
{
CommandSerializers.txnId.serialize(await.txnId, out, version);
KeySerializers.participants.serialize(await.scope, out, version);
CommandSerializers.txnId.serialize(await.txnId, out);
KeySerializers.participants.serialize(await.scope, out);
out.writeByte((await.blockedUntil.ordinal() << 1) | (await.notifyProgressLog ? 1 : 0));
out.writeUnsignedVInt(await.maxAwaitEpoch - await.txnId.epoch());
out.writeUnsignedVInt(await.maxAwaitEpoch - await.minAwaitEpoch);
@ -88,10 +88,10 @@ public class AwaitSerializers
}
@Override
public A deserialize(DataInputPlus in, int version) throws IOException
public A deserialize(DataInputPlus in) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> scope = KeySerializers.participants.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> scope = KeySerializers.participants.deserialize(in);
int blockedAndNotify = in.readByte();
BlockedUntil blockedUntil = BlockedUntil.forOrdinal(blockedAndNotify >>> 1);
boolean notifyProgressLog = (blockedAndNotify & 1) == 1;
@ -99,50 +99,50 @@ public class AwaitSerializers
long minAwaitEpoch = maxAwaitEpoch - in.readUnsignedVInt();
int callbackId = in.readUnsignedVInt32() - 1;
Invariants.require(callbackId >= -1);
return deserialize(txnId, scope, blockedUntil, notifyProgressLog, minAwaitEpoch, maxAwaitEpoch, callbackId, in, version);
return deserialize(txnId, scope, blockedUntil, notifyProgressLog, minAwaitEpoch, maxAwaitEpoch, callbackId, in);
}
@Override
public long serializedSize(A await, int version)
public long serializedSize(A await)
{
return CommandSerializers.txnId.serializedSize(await.txnId, version)
+ KeySerializers.participants.serializedSize(await.scope, version)
return CommandSerializers.txnId.serializedSize(await.txnId)
+ KeySerializers.participants.serializedSize(await.scope)
+ TypeSizes.BYTE_SIZE
+ VIntCoding.computeUnsignedVIntSize(await.maxAwaitEpoch - await.txnId.epoch())
+ VIntCoding.computeUnsignedVIntSize(await.maxAwaitEpoch - await.minAwaitEpoch)
+ VIntCoding.computeUnsignedVIntSize(await.callbackId + 1);
}
};
}
public static final IVersionedSerializer<AwaitOk> syncReply = EncodeAsVInt32.of(AwaitOk.class);
public static final IVersionedSerializer<RecoverAwaitOk> recoverReply = EncodeAsVInt32.of(RecoverAwaitOk.class);
public static final UnversionedSerializer<AwaitOk> syncReply = EncodeAsVInt32.of(AwaitOk.class);
public static final UnversionedSerializer<RecoverAwaitOk> recoverReply = EncodeAsVInt32.of(RecoverAwaitOk.class);
public static final IVersionedSerializer<AsyncAwaitComplete> asyncReply = new IVersionedSerializer<>()
public static final UnversionedSerializer<AsyncAwaitComplete> asyncReply = new UnversionedSerializer<>()
{
@Override
public void serialize(AsyncAwaitComplete ok, DataOutputPlus out, int version) throws IOException
public void serialize(AsyncAwaitComplete ok, DataOutputPlus out) throws IOException
{
CommandSerializers.txnId.serialize(ok.txnId, out, version);
KeySerializers.route.serialize(ok.route, out, version);
CommandSerializers.txnId.serialize(ok.txnId, out);
KeySerializers.route.serialize(ok.route, out);
out.writeByte(ok.newStatus.ordinal());
out.writeUnsignedVInt32(ok.callbackId);
}
@Override
public AsyncAwaitComplete deserialize(DataInputPlus in, int version) throws IOException
public AsyncAwaitComplete deserialize(DataInputPlus in) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Route<?> scope = KeySerializers.route.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Route<?> scope = KeySerializers.route.deserialize(in);
SaveStatus newStatus = SaveStatus.forOrdinal(in.readByte());
int callbackId = in.readUnsignedVInt32();
return new AsyncAwaitComplete(txnId, scope, newStatus, callbackId);
}
@Override
public long serializedSize(AsyncAwaitComplete ok, int version)
public long serializedSize(AsyncAwaitComplete ok)
{
return CommandSerializers.txnId.serializedSize(ok.txnId, version)
+ KeySerializers.route.serializedSize(ok.route, version)
return CommandSerializers.txnId.serializedSize(ok.txnId)
+ KeySerializers.route.serializedSize(ok.route)
+ TypeSizes.BYTE_SIZE
+ VIntCoding.computeVIntSize(ok.callbackId);
}

78
src/java/org/apache/cassandra/service/accord/serializers/BeginInvalidationSerializers.java
View File

@ -28,80 +28,80 @@ import accord.primitives.Participants;
import accord.primitives.Route;
import accord.primitives.SaveStatus;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public class BeginInvalidationSerializers
{
public static final IVersionedSerializer<BeginInvalidation> request = new IVersionedSerializer<>()
public static final UnversionedSerializer<BeginInvalidation> request = new UnversionedSerializer<>()
{
@Override
public void serialize(BeginInvalidation begin, DataOutputPlus out, int version) throws IOException
public void serialize(BeginInvalidation begin, DataOutputPlus out) throws IOException
{
CommandSerializers.txnId.serialize(begin.txnId, out, version);
KeySerializers.participants.serialize(begin.participants, out, version);
CommandSerializers.ballot.serialize(begin.ballot, out, version);
CommandSerializers.txnId.serialize(begin.txnId, out);
KeySerializers.participants.serialize(begin.participants, out);
CommandSerializers.ballot.serialize(begin.ballot, out);
}
@Override
public BeginInvalidation deserialize(DataInputPlus in, int version) throws IOException
public BeginInvalidation deserialize(DataInputPlus in) throws IOException
{
return new BeginInvalidation(CommandSerializers.txnId.deserialize(in, version),
KeySerializers.participants.deserialize(in, version),
CommandSerializers.ballot.deserialize(in, version));
return new BeginInvalidation(CommandSerializers.txnId.deserialize(in),
KeySerializers.participants.deserialize(in),
CommandSerializers.ballot.deserialize(in));
}
@Override
public long serializedSize(BeginInvalidation begin, int version)
public long serializedSize(BeginInvalidation begin)
{
return CommandSerializers.txnId.serializedSize(begin.txnId, version)
+ KeySerializers.participants.serializedSize(begin.participants, version)
+ CommandSerializers.ballot.serializedSize(begin.ballot, version);
return CommandSerializers.txnId.serializedSize(begin.txnId)
+ KeySerializers.participants.serializedSize(begin.participants)
+ CommandSerializers.ballot.serializedSize(begin.ballot);
}
};
public static final IVersionedSerializer<InvalidateReply> reply = new IVersionedSerializer<>()
public static final UnversionedSerializer<InvalidateReply> reply = new UnversionedSerializer<>()
{
@Override
public void serialize(InvalidateReply reply, DataOutputPlus out, int version) throws IOException
public void serialize(InvalidateReply reply, DataOutputPlus out) throws IOException
{
CommandSerializers.ballot.serialize(reply.supersededBy, out, version);
CommandSerializers.ballot.serialize(reply.accepted, out, version);
CommandSerializers.saveStatus.serialize(reply.maxStatus, out, version);
CommandSerializers.saveStatus.serialize(reply.maxKnowledgeStatus, out, version);
CommandSerializers.ballot.serialize(reply.supersededBy, out);
CommandSerializers.ballot.serialize(reply.accepted, out);
CommandSerializers.saveStatus.serialize(reply.maxStatus, out);
CommandSerializers.saveStatus.serialize(reply.maxKnowledgeStatus, out);
out.writeBoolean(reply.acceptedFastPath);
KeySerializers.nullableParticipants.serialize(reply.truncated, out, version);
KeySerializers.nullableRoute.serialize(reply.route, out, version);
KeySerializers.nullableRoutingKey.serialize(reply.homeKey, out, version);
KeySerializers.nullableParticipants.serialize(reply.truncated, out);
KeySerializers.nullableRoute.serialize(reply.route, out);
KeySerializers.nullableRoutingKey.serialize(reply.homeKey, out);
}
@Override
public InvalidateReply deserialize(DataInputPlus in, int version) throws IOException
public InvalidateReply deserialize(DataInputPlus in) throws IOException
{
// TODO (expected): use headers instead of nullable+bool serializers
Ballot supersededBy = CommandSerializers.ballot.deserialize(in, version);
Ballot accepted = CommandSerializers.ballot.deserialize(in, version);
SaveStatus maxStatus = CommandSerializers.saveStatus.deserialize(in, version);
SaveStatus maxKnowledgeStatus = CommandSerializers.saveStatus.deserialize(in, version);
Ballot supersededBy = CommandSerializers.ballot.deserialize(in);
Ballot accepted = CommandSerializers.ballot.deserialize(in);
SaveStatus maxStatus = CommandSerializers.saveStatus.deserialize(in);
SaveStatus maxKnowledgeStatus = CommandSerializers.saveStatus.deserialize(in);
boolean acceptedFastPath = in.readBoolean();
Participants<?> truncated = KeySerializers.nullableParticipants.deserialize(in, version);
Route<?> route = KeySerializers.nullableRoute.deserialize(in, version);
RoutingKey homeKey = KeySerializers.nullableRoutingKey.deserialize(in, version);
Participants<?> truncated = KeySerializers.nullableParticipants.deserialize(in);
Route<?> route = KeySerializers.nullableRoute.deserialize(in);
RoutingKey homeKey = KeySerializers.nullableRoutingKey.deserialize(in);
return new InvalidateReply(supersededBy, accepted, maxStatus, maxKnowledgeStatus, acceptedFastPath, truncated, route, homeKey);
}
@Override
public long serializedSize(InvalidateReply reply, int version)
public long serializedSize(InvalidateReply reply)
{
return CommandSerializers.ballot.serializedSize(reply.supersededBy, version)
+ CommandSerializers.ballot.serializedSize(reply.accepted, version)
+ CommandSerializers.saveStatus.serializedSize(reply.maxStatus, version)
+ CommandSerializers.saveStatus.serializedSize(reply.maxKnowledgeStatus, version)
return CommandSerializers.ballot.serializedSize(reply.supersededBy)
+ CommandSerializers.ballot.serializedSize(reply.accepted)
+ CommandSerializers.saveStatus.serializedSize(reply.maxStatus)
+ CommandSerializers.saveStatus.serializedSize(reply.maxKnowledgeStatus)
+ TypeSizes.BOOL_SIZE
+ KeySerializers.nullableParticipants.serializedSize(reply.truncated, version)
+ KeySerializers.nullableRoute.serializedSize(reply.route, version)
+ KeySerializers.nullableRoutingKey.serializedSize(reply.homeKey, version);
+ KeySerializers.nullableParticipants.serializedSize(reply.truncated)
+ KeySerializers.nullableRoute.serializedSize(reply.route)
+ KeySerializers.nullableRoutingKey.serializedSize(reply.homeKey);
}
};
}

120
src/java/org/apache/cassandra/service/accord/serializers/CheckStatusSerializers.java
View File

@ -42,7 +42,7 @@ import accord.primitives.Timestamp;
import accord.primitives.TxnId;
import accord.primitives.Writes;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
@ -52,15 +52,15 @@ import static org.apache.cassandra.service.accord.serializers.CommandSerializers
public class CheckStatusSerializers
{
public static final IVersionedSerializer<KnownMap> knownMap = new IVersionedSerializer<>()
public static final UnversionedSerializer<KnownMap> knownMap = new UnversionedSerializer<>()
{
@Override
public void serialize(KnownMap knownMap, DataOutputPlus out, int version) throws IOException
public void serialize(KnownMap knownMap, DataOutputPlus out) throws IOException
{
int size = knownMap.size();
out.writeUnsignedVInt32(size);
for (int i = 0 ; i <= size ; ++i)
KeySerializers.routingKey.serialize(knownMap.startAt(i), out, version);
KeySerializers.routingKey.serialize(knownMap.startAt(i), out);
for (int i = 0 ; i < size ; ++i)
{
KnownMap.MinMax minMax = knownMap.valueAt(i);
@ -71,39 +71,39 @@ public class CheckStatusSerializers
}
boolean equal = minMax.min.equals(minMax);
out.writeByte(equal ? 1 : 2);
known.serialize(minMax.min, out, version);
known.serialize(minMax.min, out);
if (!equal)
known.serialize(minMax, out, version);
known.serialize(minMax, out);
}
}
@Override
public KnownMap deserialize(DataInputPlus in, int version) throws IOException
public KnownMap deserialize(DataInputPlus in) throws IOException
{
int size = in.readUnsignedVInt32();
RoutingKey[] starts = new RoutingKey[size + 1];
for (int i = 0 ; i <= size ; ++i)
starts[i] = KeySerializers.routingKey.deserialize(in, version);
starts[i] = KeySerializers.routingKey.deserialize(in);
MinMax[] values = new MinMax[size];
for (int i = 0 ; i < size ; ++i)
{
int kind = in.readByte();
if (kind == 0)
continue;
Known min = known.deserialize(in, version);
Known max = kind == 1 ? min : known.deserialize(in, version);
Known min = known.deserialize(in);
Known max = kind == 1 ? min : known.deserialize(in);
values[i] = new KnownMap.MinMax(min, max);
}
return KnownMap.SerializerSupport.create(true, starts, values);
}
@Override
public long serializedSize(KnownMap knownMap, int version)
public long serializedSize(KnownMap knownMap)
{
int size = knownMap.size();
long result = TypeSizes.sizeofUnsignedVInt(size);
for (int i = 0 ; i <= size ; ++i)
result += KeySerializers.routingKey.serializedSize(knownMap.startAt(i), version);
result += KeySerializers.routingKey.serializedSize(knownMap.startAt(i));
for (int i = 0 ; i < size ; ++i)
{
KnownMap.MinMax minMax = knownMap.valueAt(i);
@ -111,42 +111,42 @@ public class CheckStatusSerializers
if (minMax == null)
continue;
boolean equal = minMax.min.equals(minMax);
result += known.serializedSize(minMax.min, version);
result += known.serializedSize(minMax.min);
if (!equal)
result += known.serializedSize(minMax, version);
result += known.serializedSize(minMax);
}
return result;
}
};
public static final IVersionedSerializer<CheckStatus> request = new IVersionedSerializer<>()
public static final UnversionedSerializer<CheckStatus> request = new UnversionedSerializer<>()
{
final CheckStatus.IncludeInfo[] infos = CheckStatus.IncludeInfo.values();
@Override
public void serialize(CheckStatus check, DataOutputPlus out, int version) throws IOException
public void serialize(CheckStatus check, DataOutputPlus out) throws IOException
{
CommandSerializers.txnId.serialize(check.txnId, out, version);
KeySerializers.participants.serialize(check.query, out, version);
CommandSerializers.txnId.serialize(check.txnId, out);
KeySerializers.participants.serialize(check.query, out);
out.writeUnsignedVInt(check.sourceEpoch);
out.writeByte(check.includeInfo.ordinal());
}
@Override
public CheckStatus deserialize(DataInputPlus in, int version) throws IOException
public CheckStatus deserialize(DataInputPlus in) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> query = KeySerializers.participants.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> query = KeySerializers.participants.deserialize(in);
long sourceEpoch = in.readUnsignedVInt();
CheckStatus.IncludeInfo info = infos[in.readByte()];
return new CheckStatus(txnId, query, sourceEpoch, info);
}
@Override
public long serializedSize(CheckStatus check, int version)
public long serializedSize(CheckStatus check)
{
return CommandSerializers.txnId.serializedSize(check.txnId, version)
+ KeySerializers.participants.serializedSize(check.query, version)
return CommandSerializers.txnId.serializedSize(check.txnId)
+ KeySerializers.participants.serializedSize(check.query)
+ TypeSizes.sizeofUnsignedVInt(check.sourceEpoch)
+ TypeSizes.BYTE_SIZE;
}
@ -159,7 +159,7 @@ public class CheckStatusSerializers
private static final byte NACK = 0x02;
@Override
public void serialize(CheckStatusReply reply, DataOutputPlus out, int version) throws IOException
public void serialize(CheckStatusReply reply, DataOutputPlus out, Version version) throws IOException
{
if (!reply.isOk())
{
@ -169,30 +169,30 @@ public class CheckStatusSerializers
CheckStatusOk ok = (CheckStatusOk) reply;
out.write(reply instanceof CheckStatusOkFull ? FULL : OK);
knownMap.serialize(ok.map, out, version);
CommandSerializers.saveStatus.serialize(ok.maxKnowledgeSaveStatus, out, version);
CommandSerializers.saveStatus.serialize(ok.maxSaveStatus, out, version);
CommandSerializers.ballot.serialize(ok.maxPromised, out, version);
CommandSerializers.ballot.serialize(ok.maxAcceptedOrCommitted, out, version);
CommandSerializers.ballot.serialize(ok.acceptedOrCommitted, out, version);
knownMap.serialize(ok.map, out);
CommandSerializers.saveStatus.serialize(ok.maxKnowledgeSaveStatus, out);
CommandSerializers.saveStatus.serialize(ok.maxSaveStatus, out);
CommandSerializers.ballot.serialize(ok.maxPromised, out);
CommandSerializers.ballot.serialize(ok.maxAcceptedOrCommitted, out);
CommandSerializers.ballot.serialize(ok.acceptedOrCommitted, out);
ExecuteAtSerializer.serializeNullable(ok.executeAt, out);
out.writeBoolean(ok.isCoordinating);
CommandSerializers.durability.serialize(ok.durability, out, version);
KeySerializers.nullableRoute.serialize(ok.route, out, version);
KeySerializers.nullableRoutingKey.serialize(ok.homeKey, out, version);
CommandSerializers.invalidIf.serialize(ok.invalidIf, out, version);
CommandSerializers.durability.serialize(ok.durability, out);
KeySerializers.nullableRoute.serialize(ok.route, out);
KeySerializers.nullableRoutingKey.serialize(ok.homeKey, out);
CommandSerializers.invalidIf.serialize(ok.invalidIf, out);
if (!(reply instanceof CheckStatusOkFull))
return;
CheckStatusOkFull okFull = (CheckStatusOkFull) ok;
CommandSerializers.nullablePartialTxn.serialize(okFull.partialTxn, out, version);
DepsSerializers.nullablePartialDeps.serialize(okFull.stableDeps, out, version);
DepsSerializers.nullablePartialDeps.serialize(okFull.stableDeps, out);
CommandSerializers.nullableWrites.serialize(okFull.writes, out, version);
}
@Override
public CheckStatusReply deserialize(DataInputPlus in, int version) throws IOException
public CheckStatusReply deserialize(DataInputPlus in, Version version) throws IOException
{
byte kind = in.readByte();
switch (kind)
@ -202,25 +202,25 @@ public class CheckStatusSerializers
return CheckStatusNack.NotOwned;
case OK:
case FULL:
KnownMap map = knownMap.deserialize(in, version);
SaveStatus maxKnowledgeStatus = CommandSerializers.saveStatus.deserialize(in, version);
SaveStatus maxStatus = CommandSerializers.saveStatus.deserialize(in, version);
Ballot maxPromised = CommandSerializers.ballot.deserialize(in, version);
Ballot maxAcceptedOrCommitted = CommandSerializers.ballot.deserialize(in, version);
Ballot acceptedOrCommitted = CommandSerializers.ballot.deserialize(in, version);
KnownMap map = knownMap.deserialize(in);
SaveStatus maxKnowledgeStatus = CommandSerializers.saveStatus.deserialize(in);
SaveStatus maxStatus = CommandSerializers.saveStatus.deserialize(in);
Ballot maxPromised = CommandSerializers.ballot.deserialize(in);
Ballot maxAcceptedOrCommitted = CommandSerializers.ballot.deserialize(in);
Ballot acceptedOrCommitted = CommandSerializers.ballot.deserialize(in);
Timestamp executeAt = ExecuteAtSerializer.deserializeNullable(in);
boolean isCoordinating = in.readBoolean();
Durability durability = CommandSerializers.durability.deserialize(in, version);
Route<?> route = KeySerializers.nullableRoute.deserialize(in, version);
RoutingKey homeKey = KeySerializers.nullableRoutingKey.deserialize(in, version);
Infer.InvalidIf invalidIf = CommandSerializers.invalidIf.deserialize(in, version);
Durability durability = CommandSerializers.durability.deserialize(in);
Route<?> route = KeySerializers.nullableRoute.deserialize(in);
RoutingKey homeKey = KeySerializers.nullableRoutingKey.deserialize(in);
Infer.InvalidIf invalidIf = CommandSerializers.invalidIf.deserialize(in);
if (kind == OK)
return createOk(map, maxKnowledgeStatus, maxStatus, maxPromised, maxAcceptedOrCommitted, acceptedOrCommitted, executeAt,
isCoordinating, durability, route, homeKey, invalidIf);
PartialTxn partialTxn = CommandSerializers.nullablePartialTxn.deserialize(in, version);
PartialDeps committedDeps = DepsSerializers.nullablePartialDeps.deserialize(in, version);
PartialDeps committedDeps = DepsSerializers.nullablePartialDeps.deserialize(in);
Writes writes = CommandSerializers.nullableWrites.deserialize(in, version);
Result result = null;
@ -234,32 +234,32 @@ public class CheckStatusSerializers
}
@Override
public long serializedSize(CheckStatusReply reply, int version)
public long serializedSize(CheckStatusReply reply, Version version)
{
long size = TypeSizes.BYTE_SIZE;
if (!reply.isOk())
return size;
CheckStatusOk ok = (CheckStatusOk) reply;
size += knownMap.serializedSize(ok.map, version);
size += CommandSerializers.saveStatus.serializedSize(ok.maxKnowledgeSaveStatus, version);
size += CommandSerializers.saveStatus.serializedSize(ok.maxSaveStatus, version);
size += CommandSerializers.ballot.serializedSize(ok.maxPromised, version);
size += CommandSerializers.ballot.serializedSize(ok.maxAcceptedOrCommitted, version);
size += CommandSerializers.ballot.serializedSize(ok.acceptedOrCommitted, version);
size += knownMap.serializedSize(ok.map);
size += CommandSerializers.saveStatus.serializedSize(ok.maxKnowledgeSaveStatus);
size += CommandSerializers.saveStatus.serializedSize(ok.maxSaveStatus);
size += CommandSerializers.ballot.serializedSize(ok.maxPromised);
size += CommandSerializers.ballot.serializedSize(ok.maxAcceptedOrCommitted);
size += CommandSerializers.ballot.serializedSize(ok.acceptedOrCommitted);
size += ExecuteAtSerializer.serializedNullableSize(ok.executeAt);
size += TypeSizes.BOOL_SIZE;
size += CommandSerializers.durability.serializedSize(ok.durability, version);
size += KeySerializers.nullableRoute.serializedSize(ok.route, version);
size += KeySerializers.nullableRoutingKey.serializedSize(ok.homeKey, version);
size += CommandSerializers.invalidIf.serializedSize(ok.invalidIf, version);
size += CommandSerializers.durability.serializedSize(ok.durability);
size += KeySerializers.nullableRoute.serializedSize(ok.route);
size += KeySerializers.nullableRoutingKey.serializedSize(ok.homeKey);
size += CommandSerializers.invalidIf.serializedSize(ok.invalidIf);
if (!(reply instanceof CheckStatusOkFull))
return size;
CheckStatusOkFull okFull = (CheckStatusOkFull) ok;
size += CommandSerializers.nullablePartialTxn.serializedSize(okFull.partialTxn, version);
size += DepsSerializers.nullablePartialDeps.serializedSize(okFull.stableDeps, version);
size += DepsSerializers.nullablePartialDeps.serializedSize(okFull.stableDeps);
size += CommandSerializers.nullableWrites.serializedSize(okFull.writes, version);
return size;
}

218
src/java/org/apache/cassandra/service/accord/serializers/CommandSerializers.java
View File

@ -49,7 +49,8 @@ import accord.primitives.Writes;
import accord.utils.Invariants;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.db.marshal.ValueAccessor;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.VersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.IVersionedWithKeysSerializer.AbstractWithKeysSerializer;
@ -68,9 +69,9 @@ public class CommandSerializers
public static final TimestampSerializer<TxnId> txnId = new TimestampSerializer<>(TxnId::fromBits);
public static final TimestampSerializer<Timestamp> timestamp = new TimestampSerializer<>(Timestamp::fromBits);
public static final IVersionedSerializer<Timestamp> nullableTimestamp = NullableSerializer.wrap(timestamp);
public static final UnversionedSerializer<Timestamp> nullableTimestamp = NullableSerializer.wrap(timestamp);
public static final BallotSerializer ballot = new BallotSerializer(); // permits null
public static final IVersionedSerializer<Txn.Kind> kind = EncodeAsVInt32.of(Txn.Kind.class);
public static final UnversionedSerializer<Txn.Kind> kind = EncodeAsVInt32.of(Txn.Kind.class);
public static final StoreParticipantsSerializer participants = new StoreParticipantsSerializer();
public static class ExecuteAtSerializer
@ -325,7 +326,7 @@ public class CommandSerializers
static final int WAITSON_IS_OWNS = 0x40;
@Override
public void serialize(StoreParticipants t, DataOutputPlus out, int version) throws IOException
public void serialize(StoreParticipants t, DataOutputPlus out, Version version) throws IOException
{
boolean hasRoute = t.route() != null;
boolean hasTouchedEqualsRoute = t.route() == t.hasTouched();
@ -342,40 +343,40 @@ public class CommandSerializers
| (executesIsOwns ? EXECUTES_IS_OWNS : 0)
| (waitsOnIsOwns ? WAITSON_IS_OWNS : 0)
);
if (hasRoute) KeySerializers.route.serialize(t.route(), out, version);
if (!hasTouchedEqualsRoute) KeySerializers.participants.serialize(t.hasTouched(), out, version);
if (!touchesEqualsHasTouched) KeySerializers.participants.serialize(t.touches(), out, version);
if (!ownsEqualsTouches) KeySerializers.participants.serialize(t.owns(), out, version);
if (!executesIsNull && !executesIsOwns) KeySerializers.participants.serialize(t.executes(), out, version);
if (!executesIsNull && !waitsOnIsOwns) KeySerializers.participants.serialize(t.waitsOn(), out, version);
if (hasRoute) KeySerializers.route.serialize(t.route(), out);
if (!hasTouchedEqualsRoute) KeySerializers.participants.serialize(t.hasTouched(), out);
if (!touchesEqualsHasTouched) KeySerializers.participants.serialize(t.touches(), out);
if (!ownsEqualsTouches) KeySerializers.participants.serialize(t.owns(), out);
if (!executesIsNull && !executesIsOwns) KeySerializers.participants.serialize(t.executes(), out);
if (!executesIsNull && !waitsOnIsOwns) KeySerializers.participants.serialize(t.waitsOn(), out);
}
public void skip(DataInputPlus in, int version) throws IOException
public void skip(DataInputPlus in, Version version) throws IOException
{
int flags = in.readByte();
if (0 != (flags & HAS_ROUTE)) KeySerializers.route.skip(in, version);
if (0 == (flags & HAS_TOUCHED_EQUALS_ROUTE)) KeySerializers.participants.skip(in, version);
if (0 == (flags & TOUCHES_EQUALS_HAS_TOUCHED)) KeySerializers.participants.skip(in, version);
if (0 == (flags & OWNS_EQUALS_TOUCHES)) KeySerializers.participants.skip(in, version);
if (0 == (flags & (EXECUTES_IS_OWNS | EXECUTES_IS_NULL))) KeySerializers.participants.skip(in, version);
if (0 == (flags & (WAITSON_IS_OWNS | EXECUTES_IS_NULL))) KeySerializers.participants.skip(in, version);
if (0 != (flags & HAS_ROUTE)) KeySerializers.route.skip(in);
if (0 == (flags & HAS_TOUCHED_EQUALS_ROUTE)) KeySerializers.participants.skip(in);
if (0 == (flags & TOUCHES_EQUALS_HAS_TOUCHED)) KeySerializers.participants.skip(in);
if (0 == (flags & OWNS_EQUALS_TOUCHES)) KeySerializers.participants.skip(in);
if (0 == (flags & (EXECUTES_IS_OWNS | EXECUTES_IS_NULL))) KeySerializers.participants.skip(in);
if (0 == (flags & (WAITSON_IS_OWNS | EXECUTES_IS_NULL))) KeySerializers.participants.skip(in);
}
@Override
public StoreParticipants deserialize(DataInputPlus in, int version) throws IOException
public StoreParticipants deserialize(DataInputPlus in, Version version) throws IOException
{
int flags = in.readByte();
Route<?> route = 0 == (flags & HAS_ROUTE) ? null : KeySerializers.route.deserialize(in, version);
Participants<?> hasTouched = 0 != (flags & HAS_TOUCHED_EQUALS_ROUTE) ? route : KeySerializers.participants.deserialize(in, version);
Participants<?> touches = 0 != (flags & TOUCHES_EQUALS_HAS_TOUCHED) ? hasTouched : KeySerializers.participants.deserialize(in, version);
Participants<?> owns = 0 != (flags & OWNS_EQUALS_TOUCHES) ? touches : KeySerializers.participants.deserialize(in, version);
Participants<?> executes = 0 != (flags & EXECUTES_IS_NULL) ? null : 0 != (flags & EXECUTES_IS_OWNS) ? owns : KeySerializers.participants.deserialize(in, version);
Participants<?> waitsOn = 0 != (flags & EXECUTES_IS_NULL) ? null : 0 != (flags & WAITSON_IS_OWNS) ? owns : KeySerializers.participants.deserialize(in, version);
Route<?> route = 0 == (flags & HAS_ROUTE) ? null : KeySerializers.route.deserialize(in);
Participants<?> hasTouched = 0 != (flags & HAS_TOUCHED_EQUALS_ROUTE) ? route : KeySerializers.participants.deserialize(in);
Participants<?> touches = 0 != (flags & TOUCHES_EQUALS_HAS_TOUCHED) ? hasTouched : KeySerializers.participants.deserialize(in);
Participants<?> owns = 0 != (flags & OWNS_EQUALS_TOUCHES) ? touches : KeySerializers.participants.deserialize(in);
Participants<?> executes = 0 != (flags & EXECUTES_IS_NULL) ? null : 0 != (flags & EXECUTES_IS_OWNS) ? owns : KeySerializers.participants.deserialize(in);
Participants<?> waitsOn = 0 != (flags & EXECUTES_IS_NULL) ? null : 0 != (flags & WAITSON_IS_OWNS) ? owns : KeySerializers.participants.deserialize(in);
return StoreParticipants.create(route, owns, executes, waitsOn, touches, hasTouched);
}
@Override
public long serializedSize(StoreParticipants t, int version)
public long serializedSize(StoreParticipants t, Version version)
{
boolean hasRoute = t.route() != null;
boolean hasTouchedEqualsRoute = t.route() == t.hasTouched();
@ -383,16 +384,16 @@ public class CommandSerializers
boolean ownsEqualsTouches = t.owns() == t.touches();
boolean executesIsNotNullAndNotOwns = t.executes() != null && t.owns() != t.executes();
long size = 1;
if (hasRoute) size += KeySerializers.route.serializedSize(t.route(), version);
if (!hasTouchedEqualsRoute) size += KeySerializers.participants.serializedSize(t.hasTouched(), version);
if (!touchesEqualsHasTouched) size += KeySerializers.participants.serializedSize(t.touches(), version);
if (!ownsEqualsTouches) size += KeySerializers.participants.serializedSize(t.owns(), version);
if (executesIsNotNullAndNotOwns) size += KeySerializers.participants.serializedSize(t.executes(), version);
if (hasRoute) size += KeySerializers.route.serializedSize(t.route());
if (!hasTouchedEqualsRoute) size += KeySerializers.participants.serializedSize(t.hasTouched());
if (!touchesEqualsHasTouched) size += KeySerializers.participants.serializedSize(t.touches());
if (!ownsEqualsTouches) size += KeySerializers.participants.serializedSize(t.owns());
if (executesIsNotNullAndNotOwns) size += KeySerializers.participants.serializedSize(t.executes());
return size;
}
}
public static class TimestampSerializer<T extends Timestamp> implements IVersionedSerializer<T>
public static class TimestampSerializer<T extends Timestamp> implements UnversionedSerializer<T>
{
interface Factory<T extends Timestamp>
{
@ -407,18 +408,11 @@ public class CommandSerializers
}
@Override
public void serialize(T ts, DataOutputPlus out, int version) throws IOException
{
out.writeLong(ts.msb);
out.writeLong(ts.lsb);
TopologySerializers.nodeId.serialize(ts.node, out, version);
}
public void serialize(T ts, DataOutputPlus out) throws IOException
{
out.writeLong(ts.msb);
out.writeLong(ts.lsb);
TopologySerializers.NodeIdSerializer.serialize(ts.node, out);
TopologySerializers.nodeId.serialize(ts.node, out);
}
public <V> int serialize(T ts, V dst, ValueAccessor<V> accessor, int offset)
@ -445,18 +439,11 @@ public class CommandSerializers
}
@Override
public T deserialize(DataInputPlus in, int version) throws IOException
{
return factory.create(in.readLong(),
in.readLong(),
TopologySerializers.nodeId.deserialize(in, version));
}
public T deserialize(DataInputPlus in) throws IOException
{
return factory.create(in.readLong(),
in.readLong(),
TopologySerializers.NodeIdSerializer.deserialize(in));
TopologySerializers.nodeId.deserialize(in));
}
public <V> T deserialize(V src, ValueAccessor<V> accessor, int offset)
@ -480,25 +467,25 @@ public class CommandSerializers
}
@Override
public long serializedSize(T ts, int version)
public long serializedSize(T ts)
{
return serializedSize();
}
public int serializedSize()
{
return TypeSizes.LONG_SIZE + // ts.msb
TypeSizes.LONG_SIZE + // ts.lsb
TopologySerializers.nodeId.serializedSize(); // ts.node
return Math.toIntExact(TypeSizes.LONG_SIZE + // ts.msb
TypeSizes.LONG_SIZE + // ts.lsb
TopologySerializers.nodeId.serializedSize(null)); // ts.node
}
}
public static class BallotSerializer implements IVersionedSerializer<Ballot>
public static class BallotSerializer implements UnversionedSerializer<Ballot>
{
final TimestampSerializer<Ballot> wrapped = new TimestampSerializer<>(Ballot::fromBits);
@Override
public void serialize(Ballot t, DataOutputPlus out, int version) throws IOException
public void serialize(Ballot t, DataOutputPlus out) throws IOException
{
if (t == null || t.equals(Ballot.ZERO) || t.equals(Ballot.MAX))
{
@ -507,16 +494,11 @@ public class CommandSerializers
else
{
out.writeByte(0);
wrapped.serialize(t, out, version);
wrapped.serialize(t, out);
}
}
@Override
public Ballot deserialize(DataInputPlus in, int version) throws IOException
{
return deserialize(in);
}
public Ballot deserialize(DataInputPlus in) throws IOException
{
int flags = in.readByte();
@ -538,11 +520,6 @@ public class CommandSerializers
}
@Override
public long serializedSize(Ballot t, int version)
{
return serializedSize(t);
}
public long serializedSize(Ballot t)
{
if (t == null || t.equals(Ballot.ZERO) || t.equals(Ballot.MAX))
@ -554,11 +531,13 @@ public class CommandSerializers
public static class PartialTxnSerializer extends AbstractWithKeysSerializer
implements IVersionedSerializer<PartialTxn>
{
private final IVersionedSerializer<Read> readSerializer;
private final IVersionedSerializer<Query> querySerializer;
private final IVersionedSerializer<Update> updateSerializer;
private final VersionedSerializer<Read, Version> readSerializer;
private final UnversionedSerializer<Query> querySerializer;
private final VersionedSerializer<Update, Version> updateSerializer;
public PartialTxnSerializer(IVersionedSerializer<Read> readSerializer, IVersionedSerializer<Query> querySerializer, IVersionedSerializer<Update> updateSerializer)
public PartialTxnSerializer(VersionedSerializer<Read, Version> readSerializer,
UnversionedSerializer<Query> querySerializer,
VersionedSerializer<Update, Version> updateSerializer)
{
this.readSerializer = readSerializer;
this.querySerializer = querySerializer;
@ -566,51 +545,51 @@ public class CommandSerializers
}
@Override
public void serialize(PartialTxn txn, DataOutputPlus out, int version) throws IOException
public void serialize(PartialTxn txn, DataOutputPlus out, Version version) throws IOException
{
KeySerializers.seekables.serialize(txn.keys(), out, version);
KeySerializers.seekables.serialize(txn.keys(), out);
serializeWithoutKeys(txn, out, version);
}
@Override
public PartialTxn deserialize(DataInputPlus in, int version) throws IOException
public PartialTxn deserialize(DataInputPlus in, Version version) throws IOException
{
Seekables<?, ?> keys = KeySerializers.seekables.deserialize(in, version);
Seekables<?, ?> keys = KeySerializers.seekables.deserialize(in);
return deserializeWithoutKeys(keys, in, version);
}
@Override
public long serializedSize(PartialTxn txn, int version)
public long serializedSize(PartialTxn txn, Version version)
{
long size = KeySerializers.seekables.serializedSize(txn.keys(), version);
long size = KeySerializers.seekables.serializedSize(txn.keys());
size += serializedSizeWithoutKeys(txn, version);
return size;
}
private void serializeWithoutKeys(PartialTxn txn, DataOutputPlus out, int version) throws IOException
private void serializeWithoutKeys(PartialTxn txn, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.kind.serialize(txn.kind(), out, version);
CommandSerializers.kind.serialize(txn.kind(), out);
readSerializer.serialize(txn.read(), out, version);
querySerializer.serialize(txn.query(), out, version);
querySerializer.serialize(txn.query(), out);
out.writeBoolean(txn.update() != null);
if (txn.update() != null)
updateSerializer.serialize(txn.update(), out, version);
}
private PartialTxn deserializeWithoutKeys(Seekables<?, ?> keys, DataInputPlus in, int version) throws IOException
private PartialTxn deserializeWithoutKeys(Seekables<?, ?> keys, DataInputPlus in, Version version) throws IOException
{
Txn.Kind kind = CommandSerializers.kind.deserialize(in, version);
Txn.Kind kind = CommandSerializers.kind.deserialize(in);
Read read = readSerializer.deserialize(in, version);
Query query = querySerializer.deserialize(in, version);
Query query = querySerializer.deserialize(in);
Update update = in.readBoolean() ? updateSerializer.deserialize(in, version) : null;
return new PartialTxn.InMemory(kind, keys, read, query, update);
}
private long serializedSizeWithoutKeys(PartialTxn txn, int version)
private long serializedSizeWithoutKeys(PartialTxn txn, Version version)
{
long size = CommandSerializers.kind.serializedSize(txn.kind(), version);
long size = CommandSerializers.kind.serializedSize(txn.kind());
size += readSerializer.serializedSize(txn.read(), version);
size += querySerializer.serializedSize(txn.query(), version);
size += querySerializer.serializedSize(txn.query());
size += TypeSizes.sizeof(txn.update() != null);
if (txn.update() != null)
size += updateSerializer.serializedSize(txn.update(), version);
@ -618,13 +597,13 @@ public class CommandSerializers
}
}
public static final IVersionedSerializer<Read> read;
public static final IVersionedSerializer<Query> query;
public static final IVersionedSerializer<Update> update;
public static final IVersionedSerializer<Write> write;
public static final VersionedSerializer<Read, Version> read;
public static final UnversionedSerializer<Query> query;
public static final VersionedSerializer<Update, Version> update;
public static final VersionedSerializer<Write, Version> write;
public static final IVersionedSerializer<PartialTxn> partialTxn;
public static final IVersionedSerializer<PartialTxn> nullablePartialTxn;
public static final VersionedSerializer<PartialTxn, Version> partialTxn;
public static final VersionedSerializer<PartialTxn, Version> nullablePartialTxn;
static
{
@ -642,26 +621,26 @@ public class CommandSerializers
@VisibleForTesting
public static class QuerySerializers
{
public final IVersionedSerializer<Read> read;
public final IVersionedSerializer<Query> query;
public final IVersionedSerializer<Update> update;
public final IVersionedSerializer<Write> write;
public final VersionedSerializer<Read, Version> read;
public final UnversionedSerializer<Query> query;
public final VersionedSerializer<Update, Version> update;
public final VersionedSerializer<Write, Version> write;
public final IVersionedSerializer<PartialTxn> partialTxn;
public final IVersionedSerializer<PartialTxn> nullablePartialTxn;
public final VersionedSerializer<PartialTxn, Version> partialTxn;
public final VersionedSerializer<PartialTxn, Version> nullablePartialTxn;
private QuerySerializers()
{
this(new CastingSerializer<>(TxnRead.class, TxnRead.serializer),
new CastingSerializer<>(TxnQuery.class, TxnQuery.serializer),
new CastingSerializer<>(AccordUpdate.class, AccordUpdate.serializer),
new CastingSerializer<>(TxnWrite.class, TxnWrite.serializer));
this(CastingSerializer.create(TxnRead.class, TxnRead.serializer),
CastingSerializer.create(TxnQuery.class, TxnQuery.serializer),
CastingSerializer.create(AccordUpdate.class, AccordUpdate.serializer),
CastingSerializer.create(TxnWrite.class, TxnWrite.serializer));
}
public QuerySerializers(IVersionedSerializer<Read> read,
IVersionedSerializer<Query> query,
IVersionedSerializer<Update> update,
IVersionedSerializer<Write> write)
public QuerySerializers(VersionedSerializer<Read, Version> read,
UnversionedSerializer<Query> query,
VersionedSerializer<Update, Version> update,
VersionedSerializer<Write, Version> write)
{
this.read = read;
this.query = query;
@ -673,18 +652,18 @@ public class CommandSerializers
}
}
public static final IVersionedSerializer<SaveStatus> saveStatus = EncodeAsVInt32.of(SaveStatus.class);
public static final IVersionedSerializer<Status> status = EncodeAsVInt32.of(Status.class);
public static final IVersionedSerializer<Durability> durability = EncodeAsVInt32.of(Durability.class);
public static final UnversionedSerializer<SaveStatus> saveStatus = EncodeAsVInt32.of(SaveStatus.class);
public static final UnversionedSerializer<Status> status = EncodeAsVInt32.of(Status.class);
public static final UnversionedSerializer<Durability> durability = EncodeAsVInt32.of(Durability.class);
public static final IVersionedSerializer<Writes> writes = new IVersionedSerializer<>()
{
@Override
public void serialize(Writes writes, DataOutputPlus out, int version) throws IOException
public void serialize(Writes writes, DataOutputPlus out, Version version) throws IOException
{
txnId.serialize(writes.txnId, out, version);
txnId.serialize(writes.txnId, out);
ExecuteAtSerializer.serialize(writes.txnId, writes.executeAt, out);
KeySerializers.seekables.serialize(writes.keys, out, version);
KeySerializers.seekables.serialize(writes.keys, out);
boolean hasWrites = writes.write != null;
out.writeBoolean(hasWrites);
@ -693,20 +672,20 @@ public class CommandSerializers
}
@Override
public Writes deserialize(DataInputPlus in, int version) throws IOException
public Writes deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId id = txnId.deserialize(in, version);
TxnId id = txnId.deserialize(in);
return new Writes(id, ExecuteAtSerializer.deserialize(id, in),
KeySerializers.seekables.deserialize(in, version),
KeySerializers.seekables.deserialize(in),
in.readBoolean() ? CommandSerializers.write.deserialize(in, version) : null);
}
@Override
public long serializedSize(Writes writes, int version)
public long serializedSize(Writes writes, Version version)
{
long size = txnId.serializedSize(writes.txnId, version);
long size = txnId.serializedSize(writes.txnId);
size += ExecuteAtSerializer.serializedSize(writes.txnId, writes.executeAt);
size += KeySerializers.seekables.serializedSize(writes.keys, version);
size += KeySerializers.seekables.serializedSize(writes.keys);
boolean hasWrites = writes.write != null;
size += TypeSizes.sizeof(hasWrites);
if (hasWrites)
@ -715,9 +694,10 @@ public class CommandSerializers
}
};
public static final IVersionedSerializer<Writes> nullableWrites = NullableSerializer.wrap(writes);
public static final IVersionedSerializer<KnownDeps> knownDeps = EncodeAsVInt32.of(KnownDeps.class);
public static final IVersionedSerializer<Infer.InvalidIf> invalidIf = EncodeAsVInt32.of(Infer.InvalidIf.class);
public static final VersionedSerializer<Writes, Version> nullableWrites = NullableSerializer.wrap(writes);
public static final UnversionedSerializer<KnownDeps> knownDeps = EncodeAsVInt32.of(KnownDeps.class);
public static final UnversionedSerializer<Infer.InvalidIf> invalidIf = EncodeAsVInt32.of(Infer.InvalidIf.class);
public static final UnversionedSerializer<Known> known = EncodeAsVInt32.withNulls(known -> known.encoded, Known::new);
public static final IVersionedSerializer<Known> known = EncodeAsVInt32.withNulls(known -> known.encoded, Known::new);
}

100
src/java/org/apache/cassandra/service/accord/serializers/CommandStoreSerializers.java
View File

@ -34,7 +34,7 @@ import accord.utils.Invariants;
import accord.utils.ReducingRangeMap;
import accord.utils.TriFunction;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.utils.CollectionSerializers;
@ -48,20 +48,21 @@ public class CommandStoreSerializers
{
private CommandStoreSerializers() {}
public static class ReducingRangeMapSerializer<T, R extends ReducingRangeMap<T>> implements IVersionedSerializer<R>
public static class ReducingRangeMapSerializer<T, R extends ReducingRangeMap<T>> implements UnversionedSerializer<R>
{
final IVersionedSerializer<T> valueSerializer;
final UnversionedSerializer<T> valueSerializer;
final IntFunction<T[]> newValueArray;
final TriFunction<Boolean, RoutingKey[], T[], R> constructor;
public ReducingRangeMapSerializer(IVersionedSerializer<T> valueSerializer, IntFunction<T[]> newValueArray, TriFunction<Boolean, RoutingKey[], T[], R> constructor)
public ReducingRangeMapSerializer(UnversionedSerializer<T> valueSerializer, IntFunction<T[]> newValueArray, TriFunction<Boolean, RoutingKey[], T[], R> constructor)
{
this.valueSerializer = valueSerializer;
this.newValueArray = newValueArray;
this.constructor = constructor;
}
public void serialize(R map, DataOutputPlus out, int version) throws IOException
@Override
public void serialize(R map, DataOutputPlus out) throws IOException
{
out.writeBoolean(map.inclusiveEnds());
int mapSize = map.size();
@ -69,14 +70,15 @@ public class CommandStoreSerializers
for (int i=0; i<mapSize; i++)
{
KeySerializers.routingKey.serialize(map.startAt(i), out, version);
valueSerializer.serialize(map.valueAt(i), out, version);
KeySerializers.routingKey.serialize(map.startAt(i), out);
valueSerializer.serialize(map.valueAt(i), out);
}
if (mapSize > 0)
KeySerializers.routingKey.serialize(map.startAt(mapSize), out, version);
KeySerializers.routingKey.serialize(map.startAt(mapSize), out);
}
public R deserialize(DataInputPlus in, int version) throws IOException
@Override
public R deserialize(DataInputPlus in) throws IOException
{
boolean inclusiveEnds = in.readBoolean();
int mapSize = in.readUnsignedVInt32();
@ -84,62 +86,63 @@ public class CommandStoreSerializers
T[] values = newValueArray.apply(mapSize);
for (int i=0; i<mapSize; i++)
{
keys[i] = KeySerializers.routingKey.deserialize(in, version);
values[i] = valueSerializer.deserialize(in, version);
keys[i] = KeySerializers.routingKey.deserialize(in);
values[i] = valueSerializer.deserialize(in);
}
if (mapSize > 0)
keys[mapSize] = KeySerializers.routingKey.deserialize(in, version);
keys[mapSize] = KeySerializers.routingKey.deserialize(in);
return constructor.apply(inclusiveEnds, keys, values);
}
public long serializedSize(R map, int version)
@Override
public long serializedSize(R map)
{
long size = TypeSizes.BOOL_SIZE;
int mapSize = map.size();
size += TypeSizes.sizeofUnsignedVInt(mapSize);
for (int i=0; i<mapSize; i++)
{
size += KeySerializers.routingKey.serializedSize(map.startAt(i), version);
size += valueSerializer.serializedSize(map.valueAt(i), version);
size += KeySerializers.routingKey.serializedSize(map.startAt(i));
size += valueSerializer.serializedSize(map.valueAt(i));
}
if (mapSize > 0)
size += KeySerializers.routingKey.serializedSize(map.startAt(mapSize), version);
size += KeySerializers.routingKey.serializedSize(map.startAt(mapSize));
return size;
}
}
public static IVersionedSerializer<DurableBefore> durableBefore = new ReducingRangeMapSerializer<>(NullableSerializer.wrap(new IVersionedSerializer<>()
public static UnversionedSerializer<DurableBefore> durableBefore = new ReducingRangeMapSerializer<>(NullableSerializer.wrap(new UnversionedSerializer<>()
{
@Override
public void serialize(DurableBefore.Entry t, DataOutputPlus out, int version) throws IOException
public void serialize(DurableBefore.Entry t, DataOutputPlus out) throws IOException
{
CommandSerializers.txnId.serialize(t.majorityBefore, out, version);
CommandSerializers.txnId.serialize(t.universalBefore, out, version);
CommandSerializers.txnId.serialize(t.majorityBefore, out);
CommandSerializers.txnId.serialize(t.universalBefore, out);
}
@Override
public DurableBefore.Entry deserialize(DataInputPlus in, int version) throws IOException
public DurableBefore.Entry deserialize(DataInputPlus in) throws IOException
{
TxnId majorityBefore = CommandSerializers.txnId.deserialize(in, version);
TxnId universalBefore = CommandSerializers.txnId.deserialize(in, version);
TxnId majorityBefore = CommandSerializers.txnId.deserialize(in);
TxnId universalBefore = CommandSerializers.txnId.deserialize(in);
return new DurableBefore.Entry(majorityBefore, universalBefore);
}
@Override
public long serializedSize(DurableBefore.Entry t, int version)
public long serializedSize(DurableBefore.Entry t)
{
return CommandSerializers.txnId.serializedSize(t.majorityBefore, version)
+ CommandSerializers.txnId.serializedSize(t.universalBefore, version);
return CommandSerializers.txnId.serializedSize(t.majorityBefore)
+ CommandSerializers.txnId.serializedSize(t.universalBefore);
}
}), DurableBefore.Entry[]::new, DurableBefore.SerializerSupport::create);
public static final IVersionedSerializer<RedundantBefore.Bounds> redundantBeforeEntry = new IVersionedSerializer<>()
public static final UnversionedSerializer<RedundantBefore.Bounds> redundantBeforeEntry = new UnversionedSerializer<>()
{
@Override
public void serialize(RedundantBefore.Bounds b, DataOutputPlus out, int version) throws IOException
public void serialize(RedundantBefore.Bounds b, DataOutputPlus out) throws IOException
{
KeySerializers.range.serialize(b.range, out, version);
KeySerializers.range.serialize(b.range, out);
Invariants.require(b.startEpoch <= b.endEpoch);
out.writeUnsignedVInt(b.startEpoch);
if (b.endEpoch == Long.MAX_VALUE) out.writeUnsignedVInt(0L);
@ -148,16 +151,16 @@ public class CommandStoreSerializers
out.writeUnsignedVInt32(b.bounds.length);
for (TxnId bound : b.bounds)
{
CommandSerializers.txnId.serialize(bound, out, version);
CommandSerializers.txnId.serialize(bound, out);
}
for (int status : b.statuses)
out.writeShort(status);
}
@Override
public RedundantBefore.Bounds deserialize(DataInputPlus in, int version) throws IOException
public RedundantBefore.Bounds deserialize(DataInputPlus in) throws IOException
{
Range range = KeySerializers.range.deserialize(in, version);
Range range = KeySerializers.range.deserialize(in);
long startEpoch = in.readUnsignedVInt();
long endEpoch = in.readUnsignedVInt();
if (endEpoch == 0) endEpoch = Long.MAX_VALUE;
@ -176,49 +179,52 @@ public class CommandStoreSerializers
}
@Override
public long serializedSize(RedundantBefore.Bounds b, int version)
public long serializedSize(RedundantBefore.Bounds b)
{
long size = KeySerializers.range.serializedSize(b.range, version);
long size = KeySerializers.range.serializedSize(b.range);
size += TypeSizes.sizeofUnsignedVInt(b.startEpoch);
size += TypeSizes.sizeofUnsignedVInt(b.endEpoch == Long.MAX_VALUE ? 0 : 1 + b.endEpoch - b.startEpoch);
size += serializedNullableSize(b.staleUntilAtLeast);
size += TypeSizes.sizeofUnsignedVInt(b.bounds.length);
for (TxnId bound : b.bounds)
{
size += CommandSerializers.txnId.serializedSize(bound, version);
size += CommandSerializers.txnId.serializedSize(bound);
}
size += 2L * b.statuses.length;
return size;
}
};
public static IVersionedSerializer<RedundantBefore> redundantBefore = new ReducingRangeMapSerializer<>(NullableSerializer.wrap(redundantBeforeEntry), RedundantBefore.Bounds[]::new, RedundantBefore.SerializerSupport::create);
public static UnversionedSerializer<RedundantBefore> redundantBefore = new ReducingRangeMapSerializer<>(NullableSerializer.wrap(redundantBeforeEntry), RedundantBefore.Bounds[]::new, RedundantBefore.SerializerSupport::create);
private static class TimestampToRangesSerializer<T extends Timestamp> implements IVersionedSerializer<NavigableMap<T, Ranges>>
private static class TimestampToRangesSerializer<T extends Timestamp> implements UnversionedSerializer<NavigableMap<T, Ranges>>
{
private final IVersionedSerializer<T> timestampSerializer;
private final UnversionedSerializer<T> timestampSerializer;
public TimestampToRangesSerializer(IVersionedSerializer<T> timestampSerializer)
public TimestampToRangesSerializer(UnversionedSerializer<T> timestampSerializer)
{
this.timestampSerializer = timestampSerializer;
}
public void serialize(NavigableMap<T, Ranges> map, DataOutputPlus out, int version) throws IOException
@Override
public void serialize(NavigableMap<T, Ranges> map, DataOutputPlus out) throws IOException
{
CollectionSerializers.serializeMap(map, out, version, timestampSerializer, KeySerializers.ranges);
CollectionSerializers.serializeMap(map, out, timestampSerializer, KeySerializers.ranges);
}
public NavigableMap<T, Ranges> deserialize(DataInputPlus in, int version) throws IOException
@Override
public NavigableMap<T, Ranges> deserialize(DataInputPlus in) throws IOException
{
return CollectionSerializers.deserializeMap(in, version, timestampSerializer, KeySerializers.ranges, i -> new TreeMap<>());
return CollectionSerializers.deserializeMap(in, timestampSerializer, KeySerializers.ranges, i -> new TreeMap<>());
}
public long serializedSize(NavigableMap<T, Ranges> map, int version)
@Override
public long serializedSize(NavigableMap<T, Ranges> map)
{
return CollectionSerializers.serializedMapSize(map, version, timestampSerializer, KeySerializers.ranges);
return CollectionSerializers.serializedMapSize(map, timestampSerializer, KeySerializers.ranges);
}
}
public static final IVersionedSerializer<NavigableMap<TxnId, Ranges>> bootstrapBeganAt = new TimestampToRangesSerializer<>(CommandSerializers.txnId);
public static final IVersionedSerializer<NavigableMap<Timestamp, Ranges>> safeToRead = new TimestampToRangesSerializer<>(CommandSerializers.timestamp);
public static final UnversionedSerializer<NavigableMap<TxnId, Ranges>> bootstrapBeganAt = new TimestampToRangesSerializer<>(CommandSerializers.txnId);
public static final UnversionedSerializer<NavigableMap<Timestamp, Ranges>> safeToRead = new TimestampToRangesSerializer<>(CommandSerializers.timestamp);
}

54
src/java/org/apache/cassandra/service/accord/serializers/CommitSerializers.java
View File

@ -30,7 +30,7 @@ import accord.primitives.Route;
import accord.primitives.Timestamp;
import accord.primitives.TxnId;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
@ -41,79 +41,79 @@ import static org.apache.cassandra.utils.NullableSerializer.serializedNullableSi
public class CommitSerializers
{
public static final IVersionedSerializer<Commit.Kind> kind = EncodeAsVInt32.of(Commit.Kind.class);
public static final UnversionedSerializer<Commit.Kind> kind = EncodeAsVInt32.of(Commit.Kind.class);
public static final CommitSerializer request = new CommitSerializer();
public static class CommitSerializer extends TxnRequestSerializer.WithUnsyncedSerializer<Commit>
{
@Override
public void serializeBody(Commit msg, DataOutputPlus out, int version) throws IOException
public void serializeBody(Commit msg, DataOutputPlus out, Version version) throws IOException
{
kind.serialize(msg.kind, out, version);
CommandSerializers.ballot.serialize(msg.ballot, out, version);
kind.serialize(msg.kind, out);
CommandSerializers.ballot.serialize(msg.ballot, out);
ExecuteAtSerializer.serialize(msg.txnId, msg.executeAt, out);
CommandSerializers.nullablePartialTxn.serialize(msg.partialTxn, out, version);
if (msg.kind.withDeps == Commit.WithDeps.HasDeps)
DepsSerializers.partialDeps.serialize(msg.partialDeps, out, version);
serializeNullable(msg.route, out, version, KeySerializers.fullRoute);
DepsSerializers.partialDeps.serialize(msg.partialDeps, out);
serializeNullable(msg.route, out, KeySerializers.fullRoute);
}
@Override
public Commit deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
public Commit deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
{
Commit.Kind kind = CommitSerializers.kind.deserialize(in, version);
Ballot ballot = CommandSerializers.ballot.deserialize(in, version);
Commit.Kind kind = CommitSerializers.kind.deserialize(in);
Ballot ballot = CommandSerializers.ballot.deserialize(in);
Timestamp executeAt = ExecuteAtSerializer.deserialize(txnId, in);
PartialTxn partialTxn = CommandSerializers.nullablePartialTxn.deserialize(in, version);
PartialDeps partialDeps = null;
if (kind.withDeps == Commit.WithDeps.HasDeps)
partialDeps = DepsSerializers.partialDeps.deserialize(in, version);
FullRoute<?> route = deserializeNullable(in, version, KeySerializers.fullRoute);
partialDeps = DepsSerializers.partialDeps.deserialize(in);
FullRoute<?> route = deserializeNullable(in, KeySerializers.fullRoute);
return Commit.SerializerSupport.create(txnId, scope, waitForEpoch, minEpoch, kind, ballot, executeAt, partialTxn, partialDeps, route);
}
@Override
public long serializedBodySize(Commit msg, int version)
public long serializedBodySize(Commit msg, Version version)
{
long size = kind.serializedSize(msg.kind, version)
+ CommandSerializers.ballot.serializedSize(msg.ballot, version)
long size = kind.serializedSize(msg.kind)
+ CommandSerializers.ballot.serializedSize(msg.ballot)
+ ExecuteAtSerializer.serializedSize(msg.txnId, msg.executeAt)
+ CommandSerializers.nullablePartialTxn.serializedSize(msg.partialTxn, version);
if (msg.kind.withDeps == Commit.WithDeps.HasDeps)
size += DepsSerializers.partialDeps.serializedSize(msg.partialDeps, version);
size += DepsSerializers.partialDeps.serializedSize(msg.partialDeps);
size += serializedNullableSize(msg.route, version, KeySerializers.fullRoute);
size += serializedNullableSize(msg.route, KeySerializers.fullRoute);
return size;
}
}
public static final IVersionedSerializer<Commit.Invalidate> invalidate = new IVersionedSerializer<>()
public static final UnversionedSerializer<Commit.Invalidate> invalidate = new UnversionedSerializer<>()
{
@Override
public void serialize(Commit.Invalidate invalidate, DataOutputPlus out, int version) throws IOException
public void serialize(Commit.Invalidate invalidate, DataOutputPlus out) throws IOException
{
CommandSerializers.txnId.serialize(invalidate.txnId, out, version);
KeySerializers.participants.serialize(invalidate.scope, out, version);
CommandSerializers.txnId.serialize(invalidate.txnId, out);
KeySerializers.participants.serialize(invalidate.scope, out);
out.writeUnsignedVInt(invalidate.waitForEpoch);
out.writeUnsignedVInt(invalidate.invalidateUntilEpoch - invalidate.waitForEpoch);
}
@Override
public Commit.Invalidate deserialize(DataInputPlus in, int version) throws IOException
public Commit.Invalidate deserialize(DataInputPlus in) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> scope = KeySerializers.participants.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> scope = KeySerializers.participants.deserialize(in);
long waitForEpoch = in.readUnsignedVInt();
long invalidateUntilEpoch = in.readUnsignedVInt() + waitForEpoch;
return Commit.Invalidate.SerializerSupport.create(txnId, scope, waitForEpoch, invalidateUntilEpoch);
}
@Override
public long serializedSize(Commit.Invalidate invalidate, int version)
public long serializedSize(Commit.Invalidate invalidate)
{
return CommandSerializers.txnId.serializedSize(invalidate.txnId, version)
+ KeySerializers.participants.serializedSize(invalidate.scope, version)
return CommandSerializers.txnId.serializedSize(invalidate.txnId)
+ KeySerializers.participants.serializedSize(invalidate.scope)
+ TypeSizes.sizeofUnsignedVInt(invalidate.waitForEpoch)
+ TypeSizes.sizeofUnsignedVInt(invalidate.invalidateUntilEpoch - invalidate.waitForEpoch);
}

76
src/java/org/apache/cassandra/service/accord/serializers/DepsSerializers.java
View File

@ -30,7 +30,7 @@ import accord.primitives.Range;
import accord.primitives.RangeDeps;
import accord.primitives.RoutingKeys;
import accord.primitives.TxnId;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.TokenRange;
@ -44,16 +44,16 @@ import static org.apache.cassandra.db.TypeSizes.sizeofUnsignedVInt;
public class DepsSerializers
{
public static final IVersionedSerializer<Range> tokenRange;
public static final UnversionedSerializer<Range> tokenRange;
public static final DepsSerializer<Deps> deps;
public static final IVersionedSerializer<Deps> nullableDeps;
public static final UnversionedSerializer<Deps> nullableDeps;
public static final DepsSerializer<PartialDeps> partialDeps;
public static final IVersionedSerializer<PartialDeps> nullablePartialDeps;
public static final UnversionedSerializer<PartialDeps> nullablePartialDeps;
static
{
// We use a separate class for initialization to make it easier for BurnTest to plug its own serializers.
Impl serializers = new Impl((IVersionedSerializer<Range>) (IVersionedSerializer<?>) TokenRange.serializer);
Impl serializers = new Impl((UnversionedSerializer<Range>) (UnversionedSerializer<?>) TokenRange.serializer);
tokenRange = serializers.tokenRange;
deps = serializers.deps;
nullableDeps = serializers.nullableDeps;
@ -61,26 +61,26 @@ public class DepsSerializers
nullablePartialDeps = serializers.nullablePartialDeps;
}
public static abstract class DepsSerializer<D extends Deps> implements IVersionedSerializer<D>
public static abstract class DepsSerializer<D extends Deps> implements UnversionedSerializer<D>
{
protected IVersionedSerializer<Range> tokenRange;
public DepsSerializer(IVersionedSerializer<Range> tokenRange)
protected UnversionedSerializer<Range> tokenRange;
public DepsSerializer(UnversionedSerializer<Range> tokenRange)
{
this.tokenRange = tokenRange;
}
abstract D deserialize(KeyDeps keyDeps, RangeDeps rangeDeps, DataInputPlus in, int version) throws IOException;
abstract D deserialize(KeyDeps keyDeps, RangeDeps rangeDeps, DataInputPlus in) throws IOException;
@Override
public void serialize(D deps, DataOutputPlus out, int version) throws IOException
public void serialize(D deps, DataOutputPlus out) throws IOException
{
{
KeyDeps keyDeps = deps.keyDeps;
KeySerializers.routingKeys.serialize(keyDeps.keys(), out, version);
KeySerializers.routingKeys.serialize(keyDeps.keys(), out);
int txnIdCount = keyDeps.txnIdCount();
out.writeUnsignedVInt32(txnIdCount);
for (int i = 0; i < txnIdCount; i++)
CommandSerializers.txnId.serialize(keyDeps.txnId(i), out, version);
CommandSerializers.txnId.serialize(keyDeps.txnId(i), out);
int keysToTxnIdsCount = keysToTxnIdsCount(keyDeps);
out.writeUnsignedVInt32(keysToTxnIdsCount);
@ -92,12 +92,12 @@ public class DepsSerializers
int rangeCount = rangeDeps.rangeCount();
out.writeUnsignedVInt32(rangeCount);
for (int i = 0; i < rangeCount; i++)
tokenRange.serialize(rangeDeps.range(i), out, version);
tokenRange.serialize(rangeDeps.range(i), out);
int txnIdCount = rangeDeps.txnIdCount();
out.writeUnsignedVInt32(txnIdCount);
for (int i = 0; i < txnIdCount; i++)
CommandSerializers.txnId.serialize(rangeDeps.txnId(i), out, version);
CommandSerializers.txnId.serialize(rangeDeps.txnId(i), out);
int rangesToTxnIdsCount = rangesToTxnIdsCount(rangeDeps);
out.writeUnsignedVInt32(rangesToTxnIdsCount);
@ -107,15 +107,15 @@ public class DepsSerializers
}
@Override
public D deserialize(DataInputPlus in, int version) throws IOException
public D deserialize(DataInputPlus in) throws IOException
{
KeyDeps keyDeps;
{
RoutingKeys keys = KeySerializers.routingKeys.deserialize(in, version);
RoutingKeys keys = KeySerializers.routingKeys.deserialize(in);
int txnIdCount = in.readUnsignedVInt32();
TxnId[] txnIds = new TxnId[txnIdCount];
for (int i = 0; i < txnIdCount; i++)
txnIds[i] = CommandSerializers.txnId.deserialize(in, version);
txnIds[i] = CommandSerializers.txnId.deserialize(in);
int keysToTxnIdsCount = in.readUnsignedVInt32();
int[] keysToTxnIds = new int[keysToTxnIdsCount];
@ -130,12 +130,12 @@ public class DepsSerializers
int rangeCount = Ints.checkedCast(in.readUnsignedVInt32());
Range[] ranges = new Range[rangeCount];
for (int i = 0; i < rangeCount; i++)
ranges[i] = tokenRange.deserialize(in, version);
ranges[i] = tokenRange.deserialize(in);
int txnIdCount = in.readUnsignedVInt32();
TxnId[] txnIds = new TxnId[txnIdCount];
for (int i = 0; i < txnIdCount; i++)
txnIds[i] = CommandSerializers.txnId.deserialize(in, version);
txnIds[i] = CommandSerializers.txnId.deserialize(in);
int rangesToTxnIdsCount = in.readUnsignedVInt32();
int[] rangesToTxnIds = new int[rangesToTxnIdsCount];
@ -144,20 +144,20 @@ public class DepsSerializers
rangeDeps = RangeDeps.SerializerSupport.create(ranges, txnIds, rangesToTxnIds);
}
return deserialize(keyDeps, rangeDeps, in, version);
return deserialize(keyDeps, rangeDeps, in);
}
@Override
public long serializedSize(D deps, int version)
public long serializedSize(D deps)
{
long size;
{
KeyDeps keyDeps = deps.keyDeps;
size = KeySerializers.routingKeys.serializedSize(deps.keyDeps.keys(), version);
size = KeySerializers.routingKeys.serializedSize(deps.keyDeps.keys());
int txnIdCount = keyDeps.txnIdCount();
size += sizeofUnsignedVInt(txnIdCount);
for (int i = 0; i < txnIdCount; i++)
size += CommandSerializers.txnId.serializedSize(keyDeps.txnId(i), version);
size += CommandSerializers.txnId.serializedSize(keyDeps.txnId(i));
int keysToTxnIdsCount = keysToTxnIdsCount(keyDeps);
size += sizeofUnsignedVInt(keysToTxnIdsCount);
@ -170,12 +170,12 @@ public class DepsSerializers
int rangeCount = rangeDeps.rangeCount();
size += sizeofUnsignedVInt(rangeCount);
for (int i = 0; i < rangeCount; ++i)
size += tokenRange.serializedSize(rangeDeps.range(i), version);
size += tokenRange.serializedSize(rangeDeps.range(i));
int txnIdCount = rangeDeps.txnIdCount();
size += sizeofUnsignedVInt(txnIdCount);
for (int i = 0; i < txnIdCount; i++)
size += CommandSerializers.txnId.serializedSize(rangeDeps.txnId(i), version);
size += CommandSerializers.txnId.serializedSize(rangeDeps.txnId(i));
int rangesToTxnIdsCount = rangesToTxnIdsCount(rangeDeps);
size += sizeofUnsignedVInt(rangesToTxnIdsCount);
@ -189,19 +189,19 @@ public class DepsSerializers
@VisibleForTesting
public static class Impl
{
final IVersionedSerializer<Range> tokenRange;
final UnversionedSerializer<Range> tokenRange;
final DepsSerializer<Deps> deps;
final IVersionedSerializer<Deps> nullableDeps;
final UnversionedSerializer<Deps> nullableDeps;
final DepsSerializer<PartialDeps> partialDeps;
final IVersionedSerializer<PartialDeps> nullablePartialDeps;
final UnversionedSerializer<PartialDeps> nullablePartialDeps;
public Impl(IVersionedSerializer<Range> tokenRange)
public Impl(UnversionedSerializer<Range> tokenRange)
{
this.tokenRange = tokenRange;
this.deps = new DepsSerializer<>(tokenRange)
{
@Override
Deps deserialize(KeyDeps keyDeps, RangeDeps rangeDeps, DataInputPlus in, int version)
Deps deserialize(KeyDeps keyDeps, RangeDeps rangeDeps, DataInputPlus in)
{
return new Deps(keyDeps, rangeDeps);
}
@ -210,24 +210,24 @@ public class DepsSerializers
this.partialDeps = new DepsSerializer<>(tokenRange)
{
@Override
PartialDeps deserialize(KeyDeps keyDeps, RangeDeps rangeDeps, DataInputPlus in, int version) throws IOException
PartialDeps deserialize(KeyDeps keyDeps, RangeDeps rangeDeps, DataInputPlus in) throws IOException
{
Participants<?> covering = KeySerializers.participants.deserialize(in, version);
Participants<?> covering = KeySerializers.participants.deserialize(in);
return new PartialDeps(covering, keyDeps, rangeDeps);
}
@Override
public void serialize(PartialDeps partialDeps, DataOutputPlus out, int version) throws IOException
public void serialize(PartialDeps partialDeps, DataOutputPlus out) throws IOException
{
super.serialize(partialDeps, out, version);
KeySerializers.participants.serialize(partialDeps.covering, out, version);
super.serialize(partialDeps, out);
KeySerializers.participants.serialize(partialDeps.covering, out);
}
@Override
public long serializedSize(PartialDeps partialDeps, int version)
public long serializedSize(PartialDeps partialDeps)
{
return super.serializedSize(partialDeps, version)
+ KeySerializers.participants.serializedSize(partialDeps.covering, version);
return super.serializedSize(partialDeps)
+ KeySerializers.participants.serializedSize(partialDeps.covering);
}
};

15
src/java/org/apache/cassandra/service/accord/serializers/EncodeAsVInt32.java
View File

@ -26,13 +26,18 @@ import javax.annotation.Nullable;
import com.google.common.primitives.Ints;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.utils.vint.VIntCoding;
public abstract class EncodeAsVInt32<T> implements IVersionedSerializer<T>
public abstract class EncodeAsVInt32<T> implements UnversionedSerializer<T>
{
/**
* Creates a serializer that uses vint to store the encoded value.
*
* Negative ints cause undefined behavior and are unsafe to use; this logic is only safe for 0 and posotive values
*/
public static <T> EncodeAsVInt32<T> withNulls(ToIntFunction<? super T> encode, IntFunction<? extends T> decode)
{
return new WithNulls<>(encode, decode);
@ -102,20 +107,20 @@ public abstract class EncodeAsVInt32<T> implements IVersionedSerializer<T>
}
@Override
public void serialize(T t, DataOutputPlus out, int version) throws IOException
public void serialize(T t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(encode(t));
}
@Override
public T deserialize(DataInputPlus in, int version) throws IOException
public T deserialize(DataInputPlus in) throws IOException
{
// we read a long to ensure we are correct even if the underlying conversion may return -1
return decode(in.readUnsignedVInt());
}
@Override
public long serializedSize(T t, int version)
public long serializedSize(T t)
{
return VIntCoding.computeUnsignedVIntSize(encode(t));
}

21
src/java/org/apache/cassandra/service/accord/serializers/EnumSerializer.java
View File

@ -19,16 +19,14 @@
package org.apache.cassandra.service.accord.serializers;
import java.io.IOException;
import java.nio.ByteBuffer;
import accord.messages.SimpleReply;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.utils.vint.VIntCoding;
public class EnumSerializer<E extends Enum<E>> implements IVersionedSerializer<E>
public class EnumSerializer<E extends Enum<E>> implements UnversionedSerializer<E>
{
public static final EnumSerializer<SimpleReply> simpleReply = new EnumSerializer<>(SimpleReply.class);
@ -45,28 +43,19 @@ public class EnumSerializer<E extends Enum<E>> implements IVersionedSerializer<E
}
@Override
public void serialize(E t, DataOutputPlus out, int version) throws IOException
public void serialize(E t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(t.ordinal());
}
@Override
public E deserialize(DataInputPlus in, int version) throws IOException
public E deserialize(DataInputPlus in) throws IOException
{
return values[in.readUnsignedVInt32()];
}
public ByteBuffer serialize(E e)
{
int len = TypeSizes.sizeofUnsignedVInt(e.ordinal());
ByteBuffer out = ByteBuffer.allocate(len);
VIntCoding.writeUnsignedVInt32(e.ordinal(), out);
out.flip();
return out;
}
@Override
public long serializedSize(E t, int version)
public long serializedSize(E t)
{
return TypeSizes.sizeofUnsignedVInt(t.ordinal());
}

54
src/java/org/apache/cassandra/service/accord/serializers/FetchSerializers.java
View File

@ -27,7 +27,7 @@ import accord.messages.ReadData.CommitOrReadNack;
import accord.messages.ReadData.ReadReply;
import accord.primitives.Ranges;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.AccordFetchCoordinator.AccordFetchRequest;
@ -44,43 +44,43 @@ public class FetchSerializers
public static final IVersionedSerializer<FetchRequest> request = new IVersionedSerializer<>()
{
@Override
public void serialize(FetchRequest request, DataOutputPlus out, int version) throws IOException
public void serialize(FetchRequest request, DataOutputPlus out, Version version) throws IOException
{
out.writeUnsignedVInt(request.executeAtEpoch);
CommandSerializers.txnId.serialize(request.txnId, out, version);
KeySerializers.ranges.serialize((Ranges) request.scope, out, version);
DepsSerializers.partialDeps.serialize(request.partialDeps, out, version);
CommandSerializers.txnId.serialize(request.txnId, out);
KeySerializers.ranges.serialize((Ranges) request.scope, out);
DepsSerializers.partialDeps.serialize(request.partialDeps, out);
StreamingTxn.serializer.serialize(request.read, out, version);
}
@Override
public FetchRequest deserialize(DataInputPlus in, int version) throws IOException
public FetchRequest deserialize(DataInputPlus in, Version version) throws IOException
{
return new AccordFetchRequest(in.readUnsignedVInt(),
CommandSerializers.txnId.deserialize(in, version),
KeySerializers.ranges.deserialize(in, version),
DepsSerializers.partialDeps.deserialize(in, version),
CommandSerializers.txnId.deserialize(in),
KeySerializers.ranges.deserialize(in),
DepsSerializers.partialDeps.deserialize(in),
StreamingTxn.serializer.deserialize(in, version));
}
@Override
public long serializedSize(FetchRequest request, int version)
public long serializedSize(FetchRequest request, Version version)
{
return TypeSizes.sizeofUnsignedVInt(request.executeAtEpoch)
+ CommandSerializers.txnId.serializedSize(request.txnId, version)
+ KeySerializers.ranges.serializedSize((Ranges) request.scope, version)
+ DepsSerializers.partialDeps.serializedSize(request.partialDeps, version)
+ CommandSerializers.txnId.serializedSize(request.txnId)
+ KeySerializers.ranges.serializedSize((Ranges) request.scope)
+ DepsSerializers.partialDeps.serializedSize(request.partialDeps)
+ StreamingTxn.serializer.serializedSize(request.read, version);
}
};
public static final IVersionedSerializer<ReadReply> reply = new IVersionedSerializer<>()
public static final UnversionedSerializer<ReadReply> reply = new UnversionedSerializer<>()
{
final CommitOrReadNack[] nacks = CommitOrReadNack.values();
final IVersionedSerializer<Data> streamDataSerializer = new CastingSerializer<>(StreamData.class, StreamData.serializer);
final UnversionedSerializer<Data> streamDataSerializer = CastingSerializer.create(StreamData.class, StreamData.serializer);
@Override
public void serialize(ReadReply reply, DataOutputPlus out, int version) throws IOException
public void serialize(ReadReply reply, DataOutputPlus out) throws IOException
{
if (!reply.isOk())
{
@ -90,34 +90,34 @@ public class FetchSerializers
out.writeByte(0);
FetchResponse response = (FetchResponse) reply;
serializeNullable(response.unavailable, out, version, KeySerializers.ranges);
serializeNullable(response.data, out, version, streamDataSerializer);
CommandSerializers.nullableTimestamp.serialize(response.safeToReadAfter, out, version);
serializeNullable(response.unavailable, out, KeySerializers.ranges);
serializeNullable(response.data, out, streamDataSerializer);
CommandSerializers.nullableTimestamp.serialize(response.safeToReadAfter, out);
}
@Override
public ReadReply deserialize(DataInputPlus in, int version) throws IOException
public ReadReply deserialize(DataInputPlus in) throws IOException
{
int id = in.readByte();
if (id != 0)
return nacks[id - 1];
return new FetchResponse(deserializeNullable(in, version, KeySerializers.ranges),
deserializeNullable(in, version, streamDataSerializer),
CommandSerializers.nullableTimestamp.deserialize(in, version));
return new FetchResponse(deserializeNullable(in, KeySerializers.ranges),
deserializeNullable(in, streamDataSerializer),
CommandSerializers.nullableTimestamp.deserialize(in));
}
@Override
public long serializedSize(ReadReply reply, int version)
public long serializedSize(ReadReply reply)
{
if (!reply.isOk())
return TypeSizes.BYTE_SIZE;
FetchResponse response = (FetchResponse) reply;
return TypeSizes.BYTE_SIZE
+ serializedNullableSize(response.unavailable, version, KeySerializers.ranges)
+ serializedNullableSize(response.data, version, streamDataSerializer)
+ CommandSerializers.nullableTimestamp.serializedSize(response.safeToReadAfter, version);
+ serializedNullableSize(response.unavailable, KeySerializers.ranges)
+ serializedNullableSize(response.data, streamDataSerializer)
+ CommandSerializers.nullableTimestamp.serializedSize(response.safeToReadAfter);
}
};

24
src/java/org/apache/cassandra/service/accord/serializers/GetDurableBeforeSerializers.java
View File

@ -21,50 +21,50 @@ import java.io.IOException;
import accord.messages.GetDurableBefore;
import accord.messages.GetDurableBefore.DurableBeforeReply;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public class GetDurableBeforeSerializers
{
public static final IVersionedSerializer<GetDurableBefore> request = new IVersionedSerializer<GetDurableBefore>()
public static final UnversionedSerializer<GetDurableBefore> request = new UnversionedSerializer<GetDurableBefore>()
{
@Override
public void serialize(GetDurableBefore msg, DataOutputPlus out, int version) throws IOException
public void serialize(GetDurableBefore msg, DataOutputPlus out) throws IOException
{
}
@Override
public GetDurableBefore deserialize(DataInputPlus in, int version) throws IOException
public GetDurableBefore deserialize(DataInputPlus in) throws IOException
{
return new GetDurableBefore();
}
@Override
public long serializedSize(GetDurableBefore msg, int version)
public long serializedSize(GetDurableBefore msg)
{
return 0;
}
};
public static final IVersionedSerializer<DurableBeforeReply> reply = new IVersionedSerializer<DurableBeforeReply>()
public static final UnversionedSerializer<DurableBeforeReply> reply = new UnversionedSerializer<DurableBeforeReply>()
{
@Override
public void serialize(DurableBeforeReply msg, DataOutputPlus out, int version) throws IOException
public void serialize(DurableBeforeReply msg, DataOutputPlus out) throws IOException
{
CommandStoreSerializers.durableBefore.serialize(msg.durableBeforeMap, out, version);
CommandStoreSerializers.durableBefore.serialize(msg.durableBeforeMap, out);
}
@Override
public DurableBeforeReply deserialize(DataInputPlus in, int version) throws IOException
public DurableBeforeReply deserialize(DataInputPlus in) throws IOException
{
return new DurableBeforeReply(CommandStoreSerializers.durableBefore.deserialize(in, version));
return new DurableBeforeReply(CommandStoreSerializers.durableBefore.deserialize(in));
}
@Override
public long serializedSize(DurableBeforeReply msg, int version)
public long serializedSize(DurableBeforeReply msg)
{
return CommandStoreSerializers.durableBefore.serializedSize(msg.durableBeforeMap, version);
return CommandStoreSerializers.durableBefore.serializedSize(msg.durableBeforeMap);
}
};
}

22
src/java/org/apache/cassandra/service/accord/serializers/GetEphmrlReadDepsSerializers.java
View File

@ -27,7 +27,7 @@ import accord.primitives.Deps;
import accord.primitives.Route;
import accord.primitives.TxnId;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
@ -36,48 +36,48 @@ public class GetEphmrlReadDepsSerializers
public static final IVersionedSerializer<GetEphemeralReadDeps> request = new TxnRequestSerializer.WithUnsyncedSerializer<GetEphemeralReadDeps>()
{
@Override
public void serializeBody(GetEphemeralReadDeps msg, DataOutputPlus out, int version) throws IOException
public void serializeBody(GetEphemeralReadDeps msg, DataOutputPlus out, Version version) throws IOException
{
out.writeUnsignedVInt(msg.executionEpoch);
}
@Override
public GetEphemeralReadDeps deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
public GetEphemeralReadDeps deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
{
long executionEpoch = in.readUnsignedVInt();
return GetEphemeralReadDeps.SerializationSupport.create(txnId, scope, waitForEpoch, minEpoch, executionEpoch);
}
@Override
public long serializedBodySize(GetEphemeralReadDeps msg, int version)
public long serializedBodySize(GetEphemeralReadDeps msg, Version version)
{
return TypeSizes.sizeofUnsignedVInt(msg.executionEpoch);
}
};
public static final IVersionedSerializer<GetEphemeralReadDepsOk> reply = new IVersionedSerializer<GetEphemeralReadDepsOk>()
public static final UnversionedSerializer<GetEphemeralReadDepsOk> reply = new UnversionedSerializer<GetEphemeralReadDepsOk>()
{
@Override
public void serialize(GetEphemeralReadDepsOk reply, DataOutputPlus out, int version) throws IOException
public void serialize(GetEphemeralReadDepsOk reply, DataOutputPlus out) throws IOException
{
DepsSerializers.deps.serialize(reply.deps, out, version);
DepsSerializers.deps.serialize(reply.deps, out);
out.writeUnsignedVInt(reply.latestEpoch);
out.writeUnsignedVInt32(reply.flags.bits());
}
@Override
public GetEphemeralReadDepsOk deserialize(DataInputPlus in, int version) throws IOException
public GetEphemeralReadDepsOk deserialize(DataInputPlus in) throws IOException
{
Deps deps = DepsSerializers.deps.deserialize(in, version);
Deps deps = DepsSerializers.deps.deserialize(in);
long latestEpoch = in.readUnsignedVInt();
ExecuteFlags flags = ExecuteFlags.get(in.readUnsignedVInt32());
return new GetEphemeralReadDepsOk(deps, latestEpoch, flags);
}
@Override
public long serializedSize(GetEphemeralReadDepsOk reply, int version)
public long serializedSize(GetEphemeralReadDepsOk reply)
{
return DepsSerializers.deps.serializedSize(reply.deps, version)
return DepsSerializers.deps.serializedSize(reply.deps)
+ TypeSizes.sizeofUnsignedVInt(reply.latestEpoch)
+ TypeSizes.sizeofUnsignedVInt(reply.flags.bits());
}

30
src/java/org/apache/cassandra/service/accord/serializers/GetMaxConflictSerializers.java
View File

@ -25,27 +25,27 @@ import accord.messages.GetMaxConflict.GetMaxConflictOk;
import accord.primitives.Route;
import accord.primitives.Timestamp;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public class GetMaxConflictSerializers
{
public static final IVersionedSerializer<GetMaxConflict> request = new IVersionedSerializer<>()
public static final UnversionedSerializer<GetMaxConflict> request = new UnversionedSerializer<>()
{
@Override
public void serialize(GetMaxConflict msg, DataOutputPlus out, int version) throws IOException
public void serialize(GetMaxConflict msg, DataOutputPlus out) throws IOException
{
KeySerializers.route.serialize(msg.scope, out, version);
KeySerializers.route.serialize(msg.scope, out);
out.writeUnsignedVInt(msg.waitForEpoch);
out.writeUnsignedVInt(msg.minEpoch);
out.writeUnsignedVInt(msg.executionEpoch);
}
@Override
public GetMaxConflict deserialize(DataInputPlus in, int version) throws IOException
public GetMaxConflict deserialize(DataInputPlus in) throws IOException
{
Route<?> scope = KeySerializers.route.deserialize(in, version);
Route<?> scope = KeySerializers.route.deserialize(in);
long waitForEpoch = in.readUnsignedVInt();
long minEpoch = in.readUnsignedVInt();
long executionEpoch = in.readUnsignedVInt();
@ -53,36 +53,36 @@ public class GetMaxConflictSerializers
}
@Override
public long serializedSize(GetMaxConflict msg, int version)
public long serializedSize(GetMaxConflict msg)
{
return KeySerializers.route.serializedSize(msg.scope(), version)
return KeySerializers.route.serializedSize(msg.scope())
+ TypeSizes.sizeofUnsignedVInt(msg.waitForEpoch)
+ TypeSizes.sizeofUnsignedVInt(msg.minEpoch)
+ TypeSizes.sizeofUnsignedVInt(msg.executionEpoch);
}
};
public static final IVersionedSerializer<GetMaxConflictOk> reply = new IVersionedSerializer<>()
public static final UnversionedSerializer<GetMaxConflictOk> reply = new UnversionedSerializer<>()
{
@Override
public void serialize(GetMaxConflictOk reply, DataOutputPlus out, int version) throws IOException
public void serialize(GetMaxConflictOk reply, DataOutputPlus out) throws IOException
{
CommandSerializers.timestamp.serialize(reply.maxConflict, out, version);
CommandSerializers.timestamp.serialize(reply.maxConflict, out);
out.writeUnsignedVInt(reply.latestEpoch);
}
@Override
public GetMaxConflictOk deserialize(DataInputPlus in, int version) throws IOException
public GetMaxConflictOk deserialize(DataInputPlus in) throws IOException
{
Timestamp maxConflict = CommandSerializers.timestamp.deserialize(in, version);
Timestamp maxConflict = CommandSerializers.timestamp.deserialize(in);
long latestEpoch = in.readUnsignedVInt();
return new GetMaxConflictOk(maxConflict, latestEpoch);
}
@Override
public long serializedSize(GetMaxConflictOk reply, int version)
public long serializedSize(GetMaxConflictOk reply)
{
return CommandSerializers.timestamp.serializedSize(reply.maxConflict, version)
return CommandSerializers.timestamp.serializedSize(reply.maxConflict)
+ TypeSizes.sizeofUnsignedVInt(reply.latestEpoch);
}
};

77
src/java/org/apache/cassandra/service/accord/serializers/IVersionedSerializer.java Normal file
View File

@ -0,0 +1,77 @@
/*
* 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.apache.cassandra.service.accord.serializers;
import java.io.IOException;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.VersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public interface IVersionedSerializer<T> extends VersionedSerializer<T, Version>
{
static <T> IVersionedSerializer<T> fromMessaging(org.apache.cassandra.io.IVersionedSerializer<T> delegate)
{
return new IVersionedSerializer<T>()
{
@Override
public void serialize(T t, DataOutputPlus out, Version version) throws IOException
{
delegate.serialize(t, out, version.messageVersion());
}
@Override
public T deserialize(DataInputPlus in, Version version) throws IOException
{
return delegate.deserialize(in, version.messageVersion());
}
@Override
public long serializedSize(T t, Version version)
{
return delegate.serializedSize(t, version.messageVersion());
}
};
}
static <T> IVersionedSerializer<T> fromSerializer(UnversionedSerializer<T> delegate)
{
return new IVersionedSerializer<T>()
{
@Override
public void serialize(T t, DataOutputPlus out, Version version) throws IOException
{
delegate.serialize(t, out);
}
@Override
public T deserialize(DataInputPlus in, Version version) throws IOException
{
return delegate.deserialize(in);
}
@Override
public long serializedSize(T t, Version version)
{
return delegate.serializedSize(t);
}
};
}
}

19
src/java/org/apache/cassandra/service/accord/serializers/IVersionedWithKeysSerializer.java
View File

@ -32,7 +32,6 @@ import accord.primitives.RoutingKeys;
import accord.primitives.Unseekables;
import net.nicoulaj.compilecommand.annotations.DontInline;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
@ -51,7 +50,7 @@ public interface IVersionedWithKeysSerializer<K extends Routables<?>, T> extends
* @param version protocol version
* @throws IOException if serialization fails
*/
void serialize(K keys, T t, DataOutputPlus out, int version) throws IOException;
void serialize(K keys, T t, DataOutputPlus out, Version version) throws IOException;
/**
* Deserialize into the specified DataInputStream instance.
@ -60,7 +59,7 @@ public interface IVersionedWithKeysSerializer<K extends Routables<?>, T> extends
* @return the type that was deserialized
* @throws IOException if deserialization fails
*/
T deserialize(K keys, DataInputPlus in, int version) throws IOException;
T deserialize(K keys, DataInputPlus in, Version version) throws IOException;
/**
* Calculate serialized size of object without actually serializing.
@ -68,7 +67,7 @@ public interface IVersionedWithKeysSerializer<K extends Routables<?>, T> extends
* @param version protocol version
* @return serialized size of object t
*/
long serializedSize(K keys, T t, int version);
long serializedSize(K keys, T t, Version version);
final class NullableWithKeysSerializer<K extends Routables<?>, T> implements IVersionedWithKeysSerializer<K, T>
{
@ -79,41 +78,41 @@ public interface IVersionedWithKeysSerializer<K extends Routables<?>, T> extends
}
@Override
public void serialize(T t, DataOutputPlus out, int version) throws IOException
public void serialize(T t, DataOutputPlus out, Version version) throws IOException
{
out.writeByte(t == null ? 0 : 1);
if (t != null) wrapped.serialize(t, out, version);
}
@Override
public T deserialize(DataInputPlus in, int version) throws IOException
public T deserialize(DataInputPlus in, Version version) throws IOException
{
if (in.readByte() == 0) return null;
return wrapped.deserialize(in, version);
}
@Override
public long serializedSize(T t, int version)
public long serializedSize(T t, Version version)
{
return t == null ? 1 : 1 + wrapped.serializedSize(t, version);
}
@Override
public void serialize(K keys, T t, DataOutputPlus out, int version) throws IOException
public void serialize(K keys, T t, DataOutputPlus out, Version version) throws IOException
{
out.writeByte(t == null ? 0 : 1);
if (t != null) wrapped.serialize(keys, t, out, version);
}
@Override
public T deserialize(K keys, DataInputPlus in, int version) throws IOException
public T deserialize(K keys, DataInputPlus in, Version version) throws IOException
{
if (in.readByte() == 0) return null;
return wrapped.deserialize(keys, in, version);
}
@Override
public long serializedSize(K keys, T t, int version)
public long serializedSize(K keys, T t, Version version)
{
return t == null ? 1 : 1 + wrapped.serializedSize(keys, t, version);
}

19
src/java/org/apache/cassandra/service/accord/serializers/InformDurableSerializers.java
View File

@ -26,7 +26,6 @@ import accord.primitives.Status;
import accord.primitives.Timestamp;
import accord.primitives.TxnId;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
@ -35,31 +34,31 @@ public class InformDurableSerializers
public static final IVersionedSerializer<InformDurable> request = new TxnRequestSerializer<InformDurable>()
{
@Override
public void serializeBody(InformDurable msg, DataOutputPlus out, int version) throws IOException
public void serializeBody(InformDurable msg, DataOutputPlus out, Version version) throws IOException
{
out.writeVInt(msg.minEpoch - msg.waitForEpoch);
out.writeVInt(msg.maxEpoch - msg.waitForEpoch);
CommandSerializers.nullableTimestamp.serialize(msg.executeAt, out, version);
CommandSerializers.durability.serialize(msg.durability, out, version);
CommandSerializers.nullableTimestamp.serialize(msg.executeAt, out);
CommandSerializers.durability.serialize(msg.durability, out);
}
@Override
public InformDurable deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch) throws IOException
public InformDurable deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch) throws IOException
{
long minEpoch = waitForEpoch + in.readVInt();
long maxEpoch = waitForEpoch + in.readVInt();
Timestamp executeAt = CommandSerializers.nullableTimestamp.deserialize(in, version);
Status.Durability durability = CommandSerializers.durability.deserialize(in, version);
Timestamp executeAt = CommandSerializers.nullableTimestamp.deserialize(in);
Status.Durability durability = CommandSerializers.durability.deserialize(in);
return InformDurable.SerializationSupport.create(txnId, scope, executeAt, minEpoch, waitForEpoch, maxEpoch, durability);
}
@Override
public long serializedBodySize(InformDurable msg, int version)
public long serializedBodySize(InformDurable msg, Version version)
{
return TypeSizes.sizeofVInt(msg.minEpoch - msg.waitForEpoch)
+ TypeSizes.sizeofVInt(msg.maxEpoch - msg.waitForEpoch)
+ CommandSerializers.nullableTimestamp.serializedSize(msg.executeAt, version)
+ CommandSerializers.durability.serializedSize(msg.durability, version);
+ CommandSerializers.nullableTimestamp.serializedSize(msg.executeAt)
+ CommandSerializers.durability.serializedSize(msg.durability);
}
};
}

312
src/java/org/apache/cassandra/service/accord/serializers/KeySerializers.java
View File

@ -54,7 +54,7 @@ import accord.primitives.Unseekables;
import accord.primitives.Unseekables.UnseekablesKind;
import accord.utils.Invariants;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.TokenRange;
@ -69,30 +69,30 @@ import static accord.utils.ArrayBuffers.cachedInts;
public class KeySerializers
{
public static final AccordKeySerializer<Key> key;
public static final IVersionedSerializer<RoutingKey> routingKey;
public static final UnversionedSerializer<RoutingKey> routingKey;
public static final IVersionedSerializer<RoutingKey> nullableRoutingKey;
public static final UnversionedSerializer<RoutingKey> nullableRoutingKey;
public static final AbstractSearchableKeysSerializer<RoutingKey, RoutingKeys> routingKeys;
public static final IVersionedSerializer<Keys> keys;
public static final UnversionedSerializer<Keys> keys;
public static final AbstractSearchableKeysSerializer<?, PartialKeyRoute> partialKeyRoute;
public static final AbstractSearchableKeysSerializer<?, FullKeyRoute> fullKeyRoute;
public static final IVersionedSerializer<Range> range;
public static final UnversionedSerializer<Range> range;
public static final AbstractRangesSerializer<Ranges> ranges;
public static final AbstractRangesSerializer<PartialRangeRoute> partialRangeRoute;
public static final AbstractRangesSerializer<FullRangeRoute> fullRangeRoute;
public static final AbstractRoutablesSerializer<Route<?>> route;
public static final IVersionedSerializer<Route<?>> nullableRoute;
public static final IVersionedSerializer<PartialRoute<?>> partialRoute;
public static final UnversionedSerializer<Route<?>> nullableRoute;
public static final UnversionedSerializer<PartialRoute<?>> partialRoute;
public static final AbstractRoutablesSerializer<FullRoute<?>> fullRoute;
public static final IVersionedSerializer<Seekables<?, ?>> seekables;
public static final IVersionedSerializer<FullRoute<?>> nullableFullRoute;
public static final UnversionedSerializer<Seekables<?, ?>> seekables;
public static final UnversionedSerializer<FullRoute<?>> nullableFullRoute;
public static final AbstractRoutablesSerializer<Unseekables<?>> unseekables;
public static final AbstractRoutablesSerializer<Participants<?>> participants;
public static final IVersionedSerializer<Participants<?>> nullableParticipants;
public static final UnversionedSerializer<Participants<?>> nullableParticipants;
static
{
@ -129,39 +129,39 @@ public class KeySerializers
final AccordKeySerializer<Key> key;
final AccordSearchableKeySerializer<RoutingKey> routingKey;
final IVersionedSerializer<RoutingKey> nullableRoutingKey;
final UnversionedSerializer<RoutingKey> nullableRoutingKey;
final AbstractSearchableKeysSerializer<RoutingKey, RoutingKeys> routingKeys;
final IVersionedSerializer<Keys> keys;
final UnversionedSerializer<Keys> keys;
final AbstractSearchableKeysSerializer<?, PartialKeyRoute> partialKeyRoute;
final AbstractSearchableKeysSerializer<?, FullKeyRoute> fullKeyRoute;
final IVersionedSerializer<Range> range;
final UnversionedSerializer<Range> range;
final AbstractRangesSerializer<Ranges> ranges;
final AbstractRangesSerializer<PartialRangeRoute> partialRangeRoute;
final AbstractRangesSerializer<FullRangeRoute> fullRangeRoute;
final AbstractRoutablesSerializer<Route<?>> route;
final IVersionedSerializer<Route<?>> nullableRoute;
final IVersionedSerializer<PartialRoute<?>> partialRoute;
final UnversionedSerializer<Route<?>> nullableRoute;
final UnversionedSerializer<PartialRoute<?>> partialRoute;
final AbstractRoutablesSerializer<FullRoute<?>> fullRoute;
final AbstractSeekablesSerializer seekables;
final IVersionedSerializer<FullRoute<?>> nullableFullRoute;
final UnversionedSerializer<FullRoute<?>> nullableFullRoute;
final AbstractRoutablesSerializer<Unseekables<?>> unseekables;
final AbstractRoutablesSerializer<Participants<?>> participants;
final IVersionedSerializer<Participants<?>> nullableParticipants;
final UnversionedSerializer<Participants<?>> nullableParticipants;
private Impl()
{
this((AccordKeySerializer<Key>) (AccordKeySerializer<?>) PartitionKey.serializer,
(AccordSearchableKeySerializer<RoutingKey>) (AccordSearchableKeySerializer<?>) TokenKey.serializer,
(IVersionedSerializer<Range>) (IVersionedSerializer<?>) TokenRange.serializer);
(UnversionedSerializer<Range>) (UnversionedSerializer<?>) TokenRange.serializer);
}
@VisibleForTesting
public Impl(AccordKeySerializer<Key> key,
AccordSearchableKeySerializer<RoutingKey> routingKey,
IVersionedSerializer<Range> range)
UnversionedSerializer<Range> range)
{
this.key = key;
this.routingKey = routingKey;
@ -170,7 +170,7 @@ public class KeySerializers
this.nullableRoutingKey = NullableSerializer.wrap(routingKey);
this.routingKeys = new AbstractSearchableKeysSerializer<>(routingKey, RoutingKey[]::new)
{
@Override RoutingKeys deserialize(DataInputPlus in, int version, RoutingKey[] keys)
@Override RoutingKeys deserialize(DataInputPlus in, RoutingKey[] keys)
{
return RoutingKeys.SerializationSupport.create(keys);
}
@ -178,7 +178,7 @@ public class KeySerializers
this.keys = new AbstractKeysSerializer<>(key, Key[]::new)
{
@Override Keys deserialize(DataInputPlus in, int version, Key[] keys)
@Override Keys deserialize(DataInputPlus in, Key[] keys)
{
return Keys.SerializationSupport.create(keys);
}
@ -186,54 +186,54 @@ public class KeySerializers
this.partialKeyRoute = new AbstractSearchableKeysSerializer<>(routingKey, RoutingKey[]::new)
{
@Override PartialKeyRoute deserialize(DataInputPlus in, int version, RoutingKey[] keys) throws IOException
@Override PartialKeyRoute deserialize(DataInputPlus in, RoutingKey[] keys) throws IOException
{
RoutingKey homeKey = routingKey.deserialize(in, version);
RoutingKey homeKey = routingKey.deserialize(in);
return PartialKeyRoute.SerializationSupport.create(homeKey, keys);
}
@Override
public void serialize(PartialKeyRoute route, DataOutputPlus out, int version) throws IOException
public void serialize(PartialKeyRoute route, DataOutputPlus out) throws IOException
{
super.serialize(route, out, version);
routingKey.serialize(route.homeKey, out, version);
super.serialize(route, out);
routingKey.serialize(route.homeKey, out);
}
@Override
public long serializedSize(PartialKeyRoute routables, int version)
public long serializedSize(PartialKeyRoute routables)
{
return super.serializedSize(routables, version)
+ routingKey.serializedSize(routables.homeKey, version);
return super.serializedSize(routables)
+ routingKey.serializedSize(routables.homeKey);
}
};
this.fullKeyRoute = new AbstractSearchableKeysSerializer<>(routingKey, RoutingKey[]::new)
{
@Override FullKeyRoute deserialize(DataInputPlus in, int version, RoutingKey[] keys) throws IOException
@Override FullKeyRoute deserialize(DataInputPlus in, RoutingKey[] keys) throws IOException
{
RoutingKey homeKey = routingKey.deserialize(in, version);
RoutingKey homeKey = routingKey.deserialize(in);
return FullKeyRoute.SerializationSupport.create(homeKey, keys);
}
@Override
public void serialize(FullKeyRoute route, DataOutputPlus out, int version) throws IOException
public void serialize(FullKeyRoute route, DataOutputPlus out) throws IOException
{
super.serialize(route, out, version);
routingKey.serialize(route.homeKey, out, version);
super.serialize(route, out);
routingKey.serialize(route.homeKey, out);
}
@Override
public long serializedSize(FullKeyRoute routables, int version)
public long serializedSize(FullKeyRoute routables)
{
return super.serializedSize(routables, version)
+ routingKey.serializedSize(routables.homeKey, version);
return super.serializedSize(routables)
+ routingKey.serializedSize(routables.homeKey);
}
};
this.ranges = new AbstractRangesSerializer<>(routingKey)
{
@Override
public Ranges deserialize(DataInputPlus in, int version, Range[] ranges)
public Ranges deserialize(DataInputPlus in, Range[] ranges)
{
return Ranges.ofSortedAndDeoverlapped(ranges);
}
@ -242,47 +242,47 @@ public class KeySerializers
this.partialRangeRoute = new AbstractRangesSerializer<>(routingKey)
{
@Override PartialRangeRoute deserialize(DataInputPlus in, int version, Range[] rs) throws IOException
@Override PartialRangeRoute deserialize(DataInputPlus in, Range[] rs) throws IOException
{
RoutingKey homeKey = routingKey.deserialize(in, version);
RoutingKey homeKey = routingKey.deserialize(in);
return PartialRangeRoute.SerializationSupport.create(homeKey, rs);
}
@Override
public void serialize(PartialRangeRoute route, DataOutputPlus out, int version) throws IOException
public void serialize(PartialRangeRoute route, DataOutputPlus out) throws IOException
{
super.serialize(route, out, version);
routingKey.serialize(route.homeKey, out, version);
super.serialize(route, out);
routingKey.serialize(route.homeKey, out);
}
@Override
public long serializedSize(PartialRangeRoute rs, int version)
public long serializedSize(PartialRangeRoute rs)
{
return super.serializedSize(rs, version)
+ routingKey.serializedSize(rs.homeKey, version);
return super.serializedSize(rs)
+ routingKey.serializedSize(rs.homeKey);
}
};
this.fullRangeRoute = new AbstractRangesSerializer<>(routingKey)
{
@Override FullRangeRoute deserialize(DataInputPlus in, int version, Range[] Ranges) throws IOException
@Override FullRangeRoute deserialize(DataInputPlus in, Range[] Ranges) throws IOException
{
RoutingKey homeKey = routingKey.deserialize(in, version);
RoutingKey homeKey = routingKey.deserialize(in);
return FullRangeRoute.SerializationSupport.create(homeKey, Ranges);
}
@Override
public void serialize(FullRangeRoute route, DataOutputPlus out, int version) throws IOException
public void serialize(FullRangeRoute route, DataOutputPlus out) throws IOException
{
super.serialize(route, out, version);
routingKey.serialize(route.homeKey, out, version);
super.serialize(route, out);
routingKey.serialize(route.homeKey, out);
}
@Override
public long serializedSize(FullRangeRoute ranges, int version)
public long serializedSize(FullRangeRoute ranges)
{
return super.serializedSize(ranges, version)
+ routingKey.serializedSize(ranges.homeKey(), version);
return super.serializedSize(ranges)
+ routingKey.serializedSize(ranges.homeKey());
}
};
@ -303,7 +303,7 @@ public class KeySerializers
}
}
public static class AbstractRoutablesSerializer<RS extends Unseekables<?>> implements IVersionedSerializer<RS>
public static class AbstractRoutablesSerializer<RS extends Unseekables<?>> implements UnversionedSerializer<RS>
{
final EnumSet<UnseekablesKind> permitted;
final AbstractSearchableKeysSerializer<RoutingKey, RoutingKeys> routingKeys;
@ -331,7 +331,7 @@ public class KeySerializers
}
@Override
public void serialize(RS t, DataOutputPlus out, int version) throws IOException
public void serialize(RS t, DataOutputPlus out) throws IOException
{
UnseekablesKind kind = t.kind();
if (!permitted.contains(kind))
@ -342,33 +342,33 @@ public class KeySerializers
default: throw new AssertionError();
case RoutingKeys:
out.writeByte(1);
routingKeys.serialize((RoutingKeys)t, out, version);
routingKeys.serialize((RoutingKeys)t, out);
break;
case PartialKeyRoute:
out.writeByte(2);
partialKeyRoute.serialize((PartialKeyRoute)t, out, version);
partialKeyRoute.serialize((PartialKeyRoute)t, out);
break;
case FullKeyRoute:
out.writeByte(3);
fullKeyRoute.serialize((FullKeyRoute)t, out, version);
fullKeyRoute.serialize((FullKeyRoute)t, out);
break;
case RoutingRanges:
out.writeByte(4);
ranges.serialize((Ranges)t, out, version);
ranges.serialize((Ranges)t, out);
break;
case PartialRangeRoute:
out.writeByte(5);
partialRangeRoute.serialize((PartialRangeRoute)t, out, version);
partialRangeRoute.serialize((PartialRangeRoute)t, out);
break;
case FullRangeRoute:
out.writeByte(6);
fullRangeRoute.serialize((FullRangeRoute)t, out, version);
fullRangeRoute.serialize((FullRangeRoute)t, out);
break;
}
}
@Override
public RS deserialize(DataInputPlus in, int version) throws IOException
public RS deserialize(DataInputPlus in) throws IOException
{
byte b = in.readByte();
UnseekablesKind kind;
@ -376,156 +376,156 @@ public class KeySerializers
switch (b)
{
default: throw new IOException("Corrupted input: expected byte 1, 2, 3, 4 or 5; received " + b);
case 1: kind = UnseekablesKind.RoutingKeys; result = (RS)routingKeys.deserialize(in, version); break;
case 2: kind = UnseekablesKind.PartialKeyRoute; result = (RS)partialKeyRoute.deserialize(in, version); break;
case 3: kind = UnseekablesKind.FullKeyRoute; result = (RS)fullKeyRoute.deserialize(in, version); break;
case 4: kind = UnseekablesKind.RoutingRanges; result = (RS)ranges.deserialize(in, version); break;
case 5: kind = UnseekablesKind.PartialRangeRoute; result = (RS)partialRangeRoute.deserialize(in, version); break;
case 6: kind = UnseekablesKind.FullRangeRoute; result = (RS)fullRangeRoute.deserialize(in, version); break;
case 1: kind = UnseekablesKind.RoutingKeys; result = (RS)routingKeys.deserialize(in); break;
case 2: kind = UnseekablesKind.PartialKeyRoute; result = (RS)partialKeyRoute.deserialize(in); break;
case 3: kind = UnseekablesKind.FullKeyRoute; result = (RS)fullKeyRoute.deserialize(in); break;
case 4: kind = UnseekablesKind.RoutingRanges; result = (RS)ranges.deserialize(in); break;
case 5: kind = UnseekablesKind.PartialRangeRoute; result = (RS)partialRangeRoute.deserialize(in); break;
case 6: kind = UnseekablesKind.FullRangeRoute; result = (RS)fullRangeRoute.deserialize(in); break;
}
Invariants.require(permitted.contains(kind));
return result;
}
public void skip(DataInputPlus in, int version) throws IOException
public void skip(DataInputPlus in) throws IOException
{
byte b = in.readByte();
switch (b)
{
default: throw new IOException("Corrupted input: expected byte 1, 2, 3, 4 or 5; received " + b);
case 1: routingKeys.skip(in, version); break;
case 2: partialKeyRoute.skip(in, version); break;
case 3: fullKeyRoute.skip(in, version); break;
case 4: ranges.skip(in, version); break;
case 5: partialRangeRoute.skip(in, version); break;
case 6: fullRangeRoute.skip(in, version); break;
case 1: routingKeys.skip(in); break;
case 2: partialKeyRoute.skip(in); break;
case 3: fullKeyRoute.skip(in); break;
case 4: ranges.skip(in); break;
case 5: partialRangeRoute.skip(in); break;
case 6: fullRangeRoute.skip(in); break;
}
}
@Override
public long serializedSize(RS t, int version)
public long serializedSize(RS t)
{
switch (t.kind())
{
default: throw new AssertionError();
case RoutingKeys:
return 1 + routingKeys.serializedSize((RoutingKeys)t, version);
return 1 + routingKeys.serializedSize((RoutingKeys)t);
case PartialKeyRoute:
return 1 + partialKeyRoute.serializedSize((PartialKeyRoute)t, version);
return 1 + partialKeyRoute.serializedSize((PartialKeyRoute)t);
case FullKeyRoute:
return 1 + fullKeyRoute.serializedSize((FullKeyRoute)t, version);
return 1 + fullKeyRoute.serializedSize((FullKeyRoute)t);
case RoutingRanges:
return 1 + ranges.serializedSize((Ranges)t, version);
return 1 + ranges.serializedSize((Ranges)t);
case PartialRangeRoute:
return 1 + partialRangeRoute.serializedSize((PartialRangeRoute)t, version);
return 1 + partialRangeRoute.serializedSize((PartialRangeRoute)t);
case FullRangeRoute:
return 1 + fullRangeRoute.serializedSize((FullRangeRoute)t, version);
return 1 + fullRangeRoute.serializedSize((FullRangeRoute)t);
}
}
}
public static final IVersionedSerializer<Seekable> seekable = new IVersionedSerializer<>()
public static final UnversionedSerializer<Seekable> seekable = new UnversionedSerializer<>()
{
@Override
public void serialize(Seekable seekable, DataOutputPlus out, int version) throws IOException
public void serialize(Seekable seekable, DataOutputPlus out) throws IOException
{
switch (seekable.domain())
{
default: throw new AssertionError();
case Key:
out.writeByte(0);
PartitionKey.serializer.serialize((PartitionKey) seekable, out, version);
PartitionKey.serializer.serialize((PartitionKey) seekable, out);
break;
case Range:
out.writeByte(1);
TokenRange.serializer.serialize((TokenRange) seekable, out, version);
TokenRange.serializer.serialize((TokenRange) seekable, out);
break;
}
}
@Override
public Seekable deserialize(DataInputPlus in, int version) throws IOException
public Seekable deserialize(DataInputPlus in) throws IOException
{
byte b = in.readByte();
switch (b)
{
default: throw new IOException("Corrupted input: expected byte 1 or 2, received " + b);
case 0: return PartitionKey.serializer.deserialize(in, version);
case 1: return TokenRange.serializer.deserialize(in, version);
case 0: return PartitionKey.serializer.deserialize(in);
case 1: return TokenRange.serializer.deserialize(in);
}
}
@Override
public long serializedSize(Seekable seekable, int version)
public long serializedSize(Seekable seekable)
{
switch (seekable.domain())
{
default: throw new AssertionError();
case Key:
return 1 + PartitionKey.serializer.serializedSize((PartitionKey) seekable, version);
return 1 + PartitionKey.serializer.serializedSize((PartitionKey) seekable);
case Range:
return 1 + TokenRange.serializer.serializedSize((TokenRange) seekable, version);
return 1 + TokenRange.serializer.serializedSize((TokenRange) seekable);
}
}
};
public static class AbstractSeekablesSerializer implements IVersionedSerializer<Seekables<?, ?>>
public static class AbstractSeekablesSerializer implements UnversionedSerializer<Seekables<?, ?>>
{
final IVersionedSerializer<Keys> keys;
final UnversionedSerializer<Keys> keys;
final AbstractRangesSerializer<Ranges> ranges;
public AbstractSeekablesSerializer(IVersionedSerializer<Keys> keys, AbstractRangesSerializer<Ranges> ranges)
public AbstractSeekablesSerializer(UnversionedSerializer<Keys> keys, AbstractRangesSerializer<Ranges> ranges)
{
this.keys = keys;
this.ranges = ranges;
}
@Override
public void serialize(Seekables<?, ?> t, DataOutputPlus out, int version) throws IOException
public void serialize(Seekables<?, ?> t, DataOutputPlus out) throws IOException
{
switch (t.domain())
{
default: throw new AssertionError();
case Key:
out.writeByte(1);
keys.serialize((Keys)t, out, version);
keys.serialize((Keys)t, out);
break;
case Range:
out.writeByte(2);
ranges.serialize((Ranges)t, out, version);
ranges.serialize((Ranges)t, out);
break;
}
}
@Override
public Seekables<?, ?> deserialize(DataInputPlus in, int version) throws IOException
public Seekables<?, ?> deserialize(DataInputPlus in) throws IOException
{
byte b = in.readByte();
switch (b)
{
default: throw new IOException("Corrupted input: expected byte 1 or 2, received " + b);
case 1: return keys.deserialize(in, version);
case 2: return ranges.deserialize(in, version);
case 1: return keys.deserialize(in);
case 2: return ranges.deserialize(in);
}
}
@Override
public long serializedSize(Seekables<?, ?> t, int version)
public long serializedSize(Seekables<?, ?> t)
{
switch (t.domain())
{
default: throw new AssertionError();
case Key:
return 1 + keys.serializedSize((Keys)t, version);
return 1 + keys.serializedSize((Keys)t);
case Range:
return 1 + ranges.serializedSize((Ranges)t, version);
return 1 + ranges.serializedSize((Ranges)t);
}
}
}
// this serializer is designed to permits using the collection in its serialized form with minimal in-memory state.
// it also saves some memory by avoiding duplicating prefixes (which happens to also assist faster lookups)
public abstract static class AbstractKeysSerializer<K extends RoutableKey, KS extends AbstractKeys<K>> implements IVersionedSerializer<KS>
public abstract static class AbstractKeysSerializer<K extends RoutableKey, KS extends AbstractKeys<K>> implements UnversionedSerializer<KS>
{
final AccordKeySerializer<K> keySerializer;
final IntFunction<K[]> allocate;
@ -537,44 +537,44 @@ public class KeySerializers
}
@Override
public void serialize(KS keys, DataOutputPlus out, int version) throws IOException
public void serialize(KS keys, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(keys.size());
for (int i=0, mi=keys.size(); i<mi; i++)
keySerializer.serialize(keys.get(i), out, version);
keySerializer.serialize(keys.get(i), out);
}
abstract KS deserialize(DataInputPlus in, int version, K[] keys) throws IOException;
abstract KS deserialize(DataInputPlus in, K[] keys) throws IOException;
public void skip(DataInputPlus in, int version) throws IOException
public void skip(DataInputPlus in) throws IOException
{
int count = in.readUnsignedVInt32();
for (int i = 0; i < count ; i++)
keySerializer.deserialize(in, version);
keySerializer.deserialize(in);
}
@Override
public KS deserialize(DataInputPlus in, int version) throws IOException
public KS deserialize(DataInputPlus in) throws IOException
{
K[] keys = allocate.apply(in.readUnsignedVInt32());
for (int i=0; i<keys.length; i++)
keys[i] = keySerializer.deserialize(in, version);
return deserialize(in, version, keys);
keys[i] = keySerializer.deserialize(in);
return deserialize(in, keys);
}
@Override
public long serializedSize(KS keys, int version)
public long serializedSize(KS keys)
{
long size = TypeSizes.sizeofUnsignedVInt(keys.size());
for (int i=0, mi=keys.size(); i<mi; i++)
size += keySerializer.serializedSize(keys.get(i), version);
size += keySerializer.serializedSize(keys.get(i));
return size;
}
}
// this serializer is designed to permits using the collection in its serialized form with minimal in-memory state.
// it also saves some memory by avoiding duplicating prefixes (which happens to also assist faster lookups)
public abstract static class AbstractSearchableSerializer<K extends RoutableKey, R extends Routable, RS extends Routables<R>> implements IVersionedSerializer<RS>
public abstract static class AbstractSearchableSerializer<K extends RoutableKey, R extends Routable, RS extends Routables<R>> implements UnversionedSerializer<RS>
{
final AccordSearchableKeySerializer<K> keySerializer;
final IntFunction<R[]> allocate;
@ -590,30 +590,30 @@ public class KeySerializers
return keySerializer.serializedSizeOfPrefix(prefix);
}
private void serializePrefix(Object prefix, DataOutputPlus out, int version) throws IOException
private void serializePrefix(Object prefix, DataOutputPlus out) throws IOException
{
keySerializer.serializePrefix(prefix, out, version);
keySerializer.serializePrefix(prefix, out);
}
private Object deserializePrefix(DataInputPlus in, int version) throws IOException
private Object deserializePrefix(DataInputPlus in) throws IOException
{
return keySerializer.deserializePrefix(in, version);
return keySerializer.deserializePrefix(in);
}
// if we store Ranges, we have twice as many indexes
abstract int recordCountToLengthCount(int recordCount);
abstract int fixedKeyLengthForPrefix(Object prefix);
abstract int serializedSizeWithoutPrefix(R routable);
abstract void serializeWithoutPrefixOrLength(R routable, DataOutputPlus out, int version) throws IOException;
abstract void serializeWithoutPrefixOrLength(R routable, DataOutputPlus out) throws IOException;
abstract void serializeOffsets(RS unseekables, int start, int end, DataOutputPlus out) throws IOException;
abstract R deserializeWithPrefix(Object prefix, int length, DataInputPlus in, int version) throws IOException;
abstract R deserializeWithPrefix(Object prefix, int lengthIndex, int[] lengths, DataInputPlus in, int version) throws IOException;
abstract R deserializeWithPrefix(Object prefix, int length, DataInputPlus in) throws IOException;
abstract R deserializeWithPrefix(Object prefix, int lengthIndex, int[] lengths, DataInputPlus in) throws IOException;
abstract RS deserialize(DataInputPlus in, int version, R[] keys) throws IOException;
abstract RS deserialize(DataInputPlus in, R[] keys) throws IOException;
@Override
public long serializedSize(RS routables, int version)
public long serializedSize(RS routables)
{
int count = routables.size();
long size = TypeSizes.sizeofUnsignedVInt(count);
@ -652,7 +652,7 @@ public class KeySerializers
}
@Override
public void serialize(RS keys, DataOutputPlus out, int version) throws IOException
public void serialize(RS keys, DataOutputPlus out) throws IOException
{
int size = keys.size();
out.writeUnsignedVInt32(size);
@ -672,11 +672,11 @@ public class KeySerializers
}
out.writeUnsignedVInt32(size - i);
serializePrefix(prefix, out, version);
serializePrefix(prefix, out);
int fixedLength = fixedKeyLengthForPrefix(prefix);
if (fixedLength < 0)
serializeOffsets(keys, prefixStart, i, out);
serializeKeysWithoutPrefix(keys, prefixStart, i, out, version);
serializeKeysWithoutPrefix(keys, prefixStart, i, out);
prefixStart = i;
prefix = nextPrefix;
}
@ -690,13 +690,13 @@ public class KeySerializers
return size;
}
private void serializeKeysWithoutPrefix(RS keys, int start, int end, DataOutputPlus out, int version) throws IOException
private void serializeKeysWithoutPrefix(RS keys, int start, int end, DataOutputPlus out) throws IOException
{
for (int i = start; i < end; ++i)
serializeWithoutPrefixOrLength(keys.get(i), out, version);
serializeWithoutPrefixOrLength(keys.get(i), out);
}
public void skip(DataInputPlus in, int version) throws IOException
public void skip(DataInputPlus in) throws IOException
{
int remaining = in.readUnsignedVInt32();
if (remaining == 0)
@ -706,7 +706,7 @@ public class KeySerializers
{
int count = remaining - in.readUnsignedVInt32();
remaining -= count;
Object prefix = deserializePrefix(in, version);
Object prefix = deserializePrefix(in);
int fixedLength = fixedKeyLengthForPrefix(prefix);
if (fixedLength >= 0)
{
@ -722,7 +722,7 @@ public class KeySerializers
}
@Override
public RS deserialize(DataInputPlus in, int version) throws IOException
public RS deserialize(DataInputPlus in) throws IOException
{
int remaining = in.readUnsignedVInt32();
R[] out = allocate.apply(remaining);
@ -731,12 +731,12 @@ public class KeySerializers
{
int count = remaining - in.readUnsignedVInt32();
remaining -= count;
Object prefix = deserializePrefix(in, version);
Object prefix = deserializePrefix(in);
int fixedLength = fixedKeyLengthForPrefix(prefix);
if (fixedLength >= 0)
{
for (int i = 0 ; i < count ; ++i)
out[outCount++] = deserializeWithPrefix(prefix, fixedLength, in, version);
out[outCount++] = deserializeWithPrefix(prefix, fixedLength, in);
}
else
{
@ -744,7 +744,7 @@ public class KeySerializers
if (lengthCount == 1)
{
int end = in.readInt();
out[outCount++] = deserializeWithPrefix(prefix, end, in, version);
out[outCount++] = deserializeWithPrefix(prefix, end, in);
}
else
{
@ -757,19 +757,19 @@ public class KeySerializers
prev = end;
}
for (int i = 0 ; i < count ; ++i)
out[outCount++] = deserializeWithPrefix(prefix, i, lengths, in, version);
out[outCount++] = deserializeWithPrefix(prefix, i, lengths, in);
cachedInts().forceDiscard(lengths);
}
}
}
return deserialize(in, version, out);
return deserialize(in, out);
}
}
// this serializer is designed to permits using the collection in its serialized form with minimal in-memory state.
// it also saves some memory by avoiding duplicating prefixes (which happens to also assist faster lookups)
public abstract static class AbstractSearchableKeysSerializer<K extends RoutableKey, KS extends AbstractKeys<K>> extends AbstractSearchableSerializer<K, K, KS> implements IVersionedSerializer<KS>
public abstract static class AbstractSearchableKeysSerializer<K extends RoutableKey, KS extends AbstractKeys<K>> extends AbstractSearchableSerializer<K, K, KS> implements UnversionedSerializer<KS>
{
public AbstractSearchableKeysSerializer(AccordSearchableKeySerializer<K> keySerializer, IntFunction<K[]> allocate)
{
@ -795,9 +795,9 @@ public class KeySerializers
}
@Override
final void serializeWithoutPrefixOrLength(K routable, DataOutputPlus out, int version) throws IOException
final void serializeWithoutPrefixOrLength(K routable, DataOutputPlus out) throws IOException
{
keySerializer.serializeWithoutPrefixOrLength(routable, out, version);
keySerializer.serializeWithoutPrefixOrLength(routable, out);
}
@Override
@ -812,19 +812,19 @@ public class KeySerializers
}
@Override
final K deserializeWithPrefix(Object prefix, int length, DataInputPlus in, int version) throws IOException
final K deserializeWithPrefix(Object prefix, int length, DataInputPlus in) throws IOException
{
return keySerializer.deserializeWithPrefix(prefix, length, in, version);
return keySerializer.deserializeWithPrefix(prefix, length, in);
}
@Override
final K deserializeWithPrefix(Object prefix, int lengthIndex, int[] lengths, DataInputPlus in, int version) throws IOException
final K deserializeWithPrefix(Object prefix, int lengthIndex, int[] lengths, DataInputPlus in) throws IOException
{
return keySerializer.deserializeWithPrefix(prefix, lengths[lengthIndex], in, version);
return keySerializer.deserializeWithPrefix(prefix, lengths[lengthIndex], in);
}
}
public abstract static class AbstractRangesSerializer<RS extends AbstractRanges> extends AbstractSearchableSerializer<RoutingKey, Range, RS> implements IVersionedSerializer<RS>
public abstract static class AbstractRangesSerializer<RS extends AbstractRanges> extends AbstractSearchableSerializer<RoutingKey, Range, RS> implements UnversionedSerializer<RS>
{
public AbstractRangesSerializer(AccordSearchableKeySerializer<RoutingKey> keySerializer)
{
@ -851,10 +851,10 @@ public class KeySerializers
}
@Override
final void serializeWithoutPrefixOrLength(Range key, DataOutputPlus out, int version) throws IOException
final void serializeWithoutPrefixOrLength(Range key, DataOutputPlus out) throws IOException
{
keySerializer.serializeWithoutPrefixOrLength(key.start(), out, version);
keySerializer.serializeWithoutPrefixOrLength(key.end(), out, version);
keySerializer.serializeWithoutPrefixOrLength(key.start(), out);
keySerializer.serializeWithoutPrefixOrLength(key.end(), out);
}
@Override
@ -872,18 +872,18 @@ public class KeySerializers
}
@Override
final Range deserializeWithPrefix(Object prefix, int length, DataInputPlus in, int version) throws IOException
final Range deserializeWithPrefix(Object prefix, int length, DataInputPlus in) throws IOException
{
RoutingKey start = keySerializer.deserializeWithPrefix(prefix, length/2, in, version);
RoutingKey end = keySerializer.deserializeWithPrefix(prefix, length/2, in, version);
RoutingKey start = keySerializer.deserializeWithPrefix(prefix, length/2, in);
RoutingKey end = keySerializer.deserializeWithPrefix(prefix, length/2, in);
return start.rangeFactory().newRange(start, end);
}
@Override
final Range deserializeWithPrefix(Object prefix, int lengthIndex, int[] lengths, DataInputPlus in, int version) throws IOException
final Range deserializeWithPrefix(Object prefix, int lengthIndex, int[] lengths, DataInputPlus in) throws IOException
{
RoutingKey start = keySerializer.deserializeWithPrefix(prefix, lengths[lengthIndex * 2], in, version);
RoutingKey end = keySerializer.deserializeWithPrefix(prefix, lengths[lengthIndex * 2 + 1], in, version);
RoutingKey start = keySerializer.deserializeWithPrefix(prefix, lengths[lengthIndex * 2], in);
RoutingKey end = keySerializer.deserializeWithPrefix(prefix, lengths[lengthIndex * 2 + 1], in);
return start.rangeFactory().newRange(start, end);
}
}

70
src/java/org/apache/cassandra/service/accord/serializers/LatestDepsSerializers.java
View File

@ -31,17 +31,17 @@ import accord.primitives.Route;
import accord.primitives.Timestamp;
import accord.primitives.TxnId;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
public class LatestDepsSerializers
{
public static final IVersionedSerializer<LatestDeps> latestDeps = new IVersionedSerializer<>()
public static final UnversionedSerializer<LatestDeps> latestDeps = new UnversionedSerializer<>()
{
@Override
public void serialize(LatestDeps t, DataOutputPlus out, int version) throws IOException
public void serialize(LatestDeps t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(t.size());
if (t.size() == 0)
@ -50,25 +50,25 @@ public class LatestDepsSerializers
for (int i = 0 ; i < t.size() ; ++i)
{
RoutingKey start = t.startAt(i);
KeySerializers.routingKey.serialize(start, out, version);
KeySerializers.routingKey.serialize(start, out);
LatestDeps.LatestEntry e = t.valueAt(i);
if (e == null)
{
CommandSerializers.knownDeps.serialize(null, out, version);
CommandSerializers.knownDeps.serialize(null, out);
}
else
{
CommandSerializers.knownDeps.serialize(e.known, out, version);
CommandSerializers.ballot.serialize(e.ballot, out, version);
DepsSerializers.nullableDeps.serialize(e.coordinatedDeps, out, version);
DepsSerializers.nullableDeps.serialize(e.localDeps, out, version);
CommandSerializers.knownDeps.serialize(e.known, out);
CommandSerializers.ballot.serialize(e.ballot, out);
DepsSerializers.nullableDeps.serialize(e.coordinatedDeps, out);
DepsSerializers.nullableDeps.serialize(e.localDeps, out);
}
}
KeySerializers.routingKey.serialize(t.startAt(t.size()), out, version);
KeySerializers.routingKey.serialize(t.startAt(t.size()), out);
}
@Override
public LatestDeps deserialize(DataInputPlus in, int version) throws IOException
public LatestDeps deserialize(DataInputPlus in) throws IOException
{
int size = in.readUnsignedVInt32();
if (size == 0)
@ -78,23 +78,23 @@ public class LatestDepsSerializers
LatestDeps.LatestEntry[] values = new LatestDeps.LatestEntry[size];
for (int i = 0 ; i < size ; ++i)
{
starts[i] = KeySerializers.routingKey.deserialize(in, version);
Known.KnownDeps knownDeps = CommandSerializers.knownDeps.deserialize(in, version);
starts[i] = KeySerializers.routingKey.deserialize(in);
Known.KnownDeps knownDeps = CommandSerializers.knownDeps.deserialize(in);
if (knownDeps == null)
continue;
Ballot ballot = CommandSerializers.ballot.deserialize(in, version);
Deps coordinatedDeps = DepsSerializers.nullableDeps.deserialize(in, version);
Deps localDeps = DepsSerializers.nullableDeps.deserialize(in, version);
Ballot ballot = CommandSerializers.ballot.deserialize(in);
Deps coordinatedDeps = DepsSerializers.nullableDeps.deserialize(in);
Deps localDeps = DepsSerializers.nullableDeps.deserialize(in);
values[i] = new LatestDeps.LatestEntry(knownDeps, ballot, coordinatedDeps, localDeps);
}
starts[size] = KeySerializers.routingKey.deserialize(in, version);
starts[size] = KeySerializers.routingKey.deserialize(in);
return LatestDeps.SerializerSupport.create(true, starts, values);
}
@Override
public long serializedSize(LatestDeps t, int version)
public long serializedSize(LatestDeps t)
{
long size = 0;
size += TypeSizes.sizeofUnsignedVInt(t.size());
@ -103,21 +103,21 @@ public class LatestDepsSerializers
for (int i = 0 ; i < t.size() ; ++i)
{
RoutingKey start = t.startAt(i);
size += KeySerializers.routingKey.serializedSize(start, version);
size += KeySerializers.routingKey.serializedSize(start);
LatestDeps.LatestEntry e = t.valueAt(i);
if (e == null)
{
size += CommandSerializers.knownDeps.serializedSize(null, version);
size += CommandSerializers.knownDeps.serializedSize(null);
}
else
{
size += CommandSerializers.knownDeps.serializedSize(e.known, version);
size += CommandSerializers.ballot.serializedSize(e.ballot, version);
size += DepsSerializers.nullableDeps.serializedSize(e.coordinatedDeps, version);
size += DepsSerializers.nullableDeps.serializedSize(e.localDeps, version);
size += CommandSerializers.knownDeps.serializedSize(e.known);
size += CommandSerializers.ballot.serializedSize(e.ballot);
size += DepsSerializers.nullableDeps.serializedSize(e.coordinatedDeps);
size += DepsSerializers.nullableDeps.serializedSize(e.localDeps);
}
}
size += KeySerializers.routingKey.serializedSize(t.startAt(t.size()), version);
size += KeySerializers.routingKey.serializedSize(t.startAt(t.size()));
return size;
}
};
@ -125,13 +125,13 @@ public class LatestDepsSerializers
public static final IVersionedSerializer<GetLatestDeps> request = new TxnRequestSerializer.WithUnsyncedSerializer<>()
{
@Override
public void serializeBody(GetLatestDeps msg, DataOutputPlus out, int version) throws IOException
public void serializeBody(GetLatestDeps msg, DataOutputPlus out, Version version) throws IOException
{
ExecuteAtSerializer.serialize(msg.executeAt, out);
}
@Override
public GetLatestDeps deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
public GetLatestDeps deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
{
Ballot ballot = CommandSerializers.ballot.deserialize(in);
Timestamp executeAt = ExecuteAtSerializer.deserialize(in);
@ -139,30 +139,30 @@ public class LatestDepsSerializers
}
@Override
public long serializedBodySize(GetLatestDeps msg, int version)
public long serializedBodySize(GetLatestDeps msg, Version version)
{
return ExecuteAtSerializer.serializedSize(msg.executeAt);
}
};
public static final IVersionedSerializer<GetLatestDepsOk> reply = new IVersionedSerializer<>()
public static final UnversionedSerializer<GetLatestDepsOk> reply = new UnversionedSerializer<>()
{
@Override
public void serialize(GetLatestDepsOk reply, DataOutputPlus out, int version) throws IOException
public void serialize(GetLatestDepsOk reply, DataOutputPlus out) throws IOException
{
latestDeps.serialize(reply.deps, out, version);
latestDeps.serialize(reply.deps, out);
}
@Override
public GetLatestDepsOk deserialize(DataInputPlus in, int version) throws IOException
public GetLatestDepsOk deserialize(DataInputPlus in) throws IOException
{
return new GetLatestDepsOk(latestDeps.deserialize(in, version));
return new GetLatestDepsOk(latestDeps.deserialize(in));
}
@Override
public long serializedSize(GetLatestDepsOk reply, int version)
public long serializedSize(GetLatestDepsOk reply)
{
return latestDeps.serializedSize(reply.deps, version);
return latestDeps.serializedSize(reply.deps);
}
};
}

40
src/java/org/apache/cassandra/service/accord/serializers/PreacceptSerializers.java
View File

@ -31,7 +31,7 @@ import accord.primitives.PartialTxn;
import accord.primitives.Route;
import accord.primitives.TxnId;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
@ -45,7 +45,7 @@ public class PreacceptSerializers
public static final IVersionedSerializer<PreAccept> request = new WithUnsyncedSerializer<>()
{
@Override
public void serializeBody(PreAccept msg, DataOutputPlus out, int version) throws IOException
public void serializeBody(PreAccept msg, DataOutputPlus out, Version version) throws IOException
{
int flags = (msg.partialDeps == null ? 0 : 1)
| (msg.route == null ? 0 : 2)
@ -54,76 +54,76 @@ public class PreacceptSerializers
out.writeByte(flags);
CommandSerializers.partialTxn.serialize(msg.partialTxn, out, version);
if (msg.partialDeps != null)
DepsSerializers.partialDeps.serialize(msg.partialDeps, out, version);
DepsSerializers.partialDeps.serialize(msg.partialDeps, out);
if (msg.route != null)
KeySerializers.fullRoute.serialize(msg.route, out, version);
KeySerializers.fullRoute.serialize(msg.route, out);
if (msg.acceptEpoch != msg.minEpoch)
out.writeUnsignedVInt(msg.acceptEpoch - msg.minEpoch);
}
@Override
public PreAccept deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
public PreAccept deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
{
byte flags = in.readByte();
PartialTxn partialTxn = CommandSerializers.partialTxn.deserialize(in, version);
@Nullable PartialDeps partialDeps = (flags & 1) == 0 ? null : DepsSerializers.partialDeps.deserialize(in, version);
@Nullable FullRoute<?> fullRoute = (flags & 2) == 0 ? null : KeySerializers.fullRoute.deserialize(in, version);
@Nullable PartialDeps partialDeps = (flags & 1) == 0 ? null : DepsSerializers.partialDeps.deserialize(in);
@Nullable FullRoute<?> fullRoute = (flags & 2) == 0 ? null : KeySerializers.fullRoute.deserialize(in);
boolean hasCoordinatorVote = (flags & 4) != 0;
long acceptEpoch = (flags & 8) == 0 ? minEpoch : in.readUnsignedVInt() + minEpoch;
return PreAccept.SerializerSupport.create(txnId, scope, waitForEpoch, minEpoch, acceptEpoch, partialTxn, partialDeps, hasCoordinatorVote, fullRoute);
}
@Override
public long serializedBodySize(PreAccept msg, int version)
public long serializedBodySize(PreAccept msg, Version version)
{
return TypeSizes.BYTE_SIZE
+ CommandSerializers.partialTxn.serializedSize(msg.partialTxn, version)
+ (msg.partialDeps == null ? 0 : DepsSerializers.partialDeps.serializedSize(msg.partialDeps, version))
+ (msg.route == null ? 0 : KeySerializers.fullRoute.serializedSize(msg.route, version))
+ (msg.partialDeps == null ? 0 : DepsSerializers.partialDeps.serializedSize(msg.partialDeps))
+ (msg.route == null ? 0 : KeySerializers.fullRoute.serializedSize(msg.route))
+ (msg.acceptEpoch == msg.minEpoch ? 0 : TypeSizes.sizeofUnsignedVInt(msg.acceptEpoch - msg.minEpoch));
}
};
public static final IVersionedSerializer<PreAcceptReply> reply = new IVersionedSerializer<>()
public static final UnversionedSerializer<PreAcceptReply> reply = new UnversionedSerializer<>()
{
@Override
public void serialize(PreAcceptReply reply, DataOutputPlus out, int version) throws IOException
public void serialize(PreAcceptReply reply, DataOutputPlus out) throws IOException
{
out.writeBoolean(reply.isOk());
if (!reply.isOk())
return;
PreAcceptOk preAcceptOk = (PreAcceptOk) reply;
CommandSerializers.txnId.serialize(preAcceptOk.txnId, out, version);
CommandSerializers.txnId.serialize(preAcceptOk.txnId, out);
ExecuteAtSerializer.serialize(preAcceptOk.txnId, preAcceptOk.witnessedAt, out);
DepsSerializers.deps.serialize(preAcceptOk.deps, out, version);
DepsSerializers.deps.serialize(preAcceptOk.deps, out);
out.writeUnsignedVInt32(preAcceptOk.flags.bits());
}
@Override
public PreAcceptReply deserialize(DataInputPlus in, int version) throws IOException
public PreAcceptReply deserialize(DataInputPlus in) throws IOException
{
if (!in.readBoolean())
return PreAccept.PreAcceptNack.INSTANCE;
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
return new PreAcceptOk(txnId,
ExecuteAtSerializer.deserialize(txnId, in),
DepsSerializers.deps.deserialize(in, version),
DepsSerializers.deps.deserialize(in),
ExecuteFlags.get(in.readUnsignedVInt32()));
}
@Override
public long serializedSize(PreAcceptReply reply, int version)
public long serializedSize(PreAcceptReply reply)
{
long size = TypeSizes.sizeof(reply.isOk());
if (!reply.isOk())
return size;
PreAcceptOk preAcceptOk = (PreAcceptOk) reply;
size += CommandSerializers.txnId.serializedSize(preAcceptOk.txnId, version);
size += CommandSerializers.txnId.serializedSize(preAcceptOk.txnId);
size += ExecuteAtSerializer.serializedSize(preAcceptOk.txnId, preAcceptOk.witnessedAt);
size += DepsSerializers.deps.serializedSize(preAcceptOk.deps, version);
size += DepsSerializers.deps.serializedSize(preAcceptOk.deps);
size += TypeSizes.sizeofUnsignedVInt(preAcceptOk.flags.bits());
return size;
}

162
src/java/org/apache/cassandra/service/accord/serializers/ReadDataSerializers.java
View File

@ -41,7 +41,7 @@ import accord.primitives.Ranges;
import accord.primitives.Timestamp;
import accord.primitives.TxnId;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.VersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
@ -61,20 +61,20 @@ public class ReadDataSerializers
public static final IVersionedSerializer<ReadData> readData = new IVersionedSerializer<ReadData>()
{
@Override
public void serialize(ReadData t, DataOutputPlus out, int version) throws IOException
public void serialize(ReadData t, DataOutputPlus out, Version version) throws IOException
{
out.writeByte(t.kind().val);
serializerFor(t).serialize(t, out, version);
}
@Override
public ReadData deserialize(DataInputPlus in, int version) throws IOException
public ReadData deserialize(DataInputPlus in, Version version) throws IOException
{
return serializerFor(ReadType.valueOf(in.readByte())).deserialize(in, version);
}
@Override
public long serializedSize(ReadData t, int version)
public long serializedSize(ReadData t, Version version)
{
return sizeof(t.kind().val) + serializerFor(t).serializedSize(t, version);
}
@ -85,44 +85,44 @@ public class ReadDataSerializers
public static class ApplyThenWaitUntilAppliedSerializer implements ReadDataSerializer<ApplyThenWaitUntilApplied>
{
@Override
public void serialize(ApplyThenWaitUntilApplied msg, DataOutputPlus out, int version) throws IOException
public void serialize(ApplyThenWaitUntilApplied msg, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(msg.txnId, out, version);
KeySerializers.participants.serialize(msg.scope, out, version);
CommandSerializers.txnId.serialize(msg.txnId, out);
KeySerializers.participants.serialize(msg.scope, out);
out.writeUnsignedVInt(msg.minEpoch());
ExecuteAtSerializer.serialize(msg.txnId, msg.executeAt, out);
KeySerializers.fullRoute.serialize(msg.route, out, version);
KeySerializers.fullRoute.serialize(msg.route, out);
CommandSerializers.partialTxn.serialize(msg.txn, out, version);
DepsSerializers.partialDeps.serialize(msg.deps, out, version);
DepsSerializers.partialDeps.serialize(msg.deps, out);
CommandSerializers.nullableWrites.serialize(msg.writes, out, version);
}
@Override
public ApplyThenWaitUntilApplied deserialize(DataInputPlus in, int version) throws IOException
public ApplyThenWaitUntilApplied deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
return ApplyThenWaitUntilApplied.SerializerSupport.create(
txnId,
KeySerializers.participants.deserialize(in, version),
KeySerializers.participants.deserialize(in),
in.readUnsignedVInt(),
ExecuteAtSerializer.deserialize(txnId, in),
KeySerializers.fullRoute.deserialize(in, version),
KeySerializers.fullRoute.deserialize(in),
CommandSerializers.partialTxn.deserialize(in, version),
DepsSerializers.partialDeps.deserialize(in, version),
DepsSerializers.partialDeps.deserialize(in),
CommandSerializers.nullableWrites.deserialize(in, version),
ResultSerializers.APPLIED);
}
@Override
public long serializedSize(ApplyThenWaitUntilApplied msg, int version)
public long serializedSize(ApplyThenWaitUntilApplied msg, Version version)
{
return CommandSerializers.txnId.serializedSize(msg.txnId, version)
+ KeySerializers.participants.serializedSize(msg.scope, version)
return CommandSerializers.txnId.serializedSize(msg.txnId)
+ KeySerializers.participants.serializedSize(msg.scope)
+ TypeSizes.sizeofUnsignedVInt(msg.minEpoch())
+ ExecuteAtSerializer.serializedSize(msg.txnId, msg.executeAt)
+ KeySerializers.fullRoute.serializedSize(msg.route, version)
+ KeySerializers.fullRoute.serializedSize(msg.route)
+ CommandSerializers.partialTxn.serializedSize(msg.txn, version)
+ DepsSerializers.partialDeps.serializedSize(msg.deps, version)
+ DepsSerializers.partialDeps.serializedSize(msg.deps)
+ CommandSerializers.nullableWrites.serializedSize(msg.writes, version);
}
}
@ -130,27 +130,27 @@ public class ReadDataSerializers
private static final ReadDataSerializer<ReadTxnData> readTxnData = new ReadDataSerializer<ReadTxnData>()
{
@Override
public void serialize(ReadTxnData read, DataOutputPlus out, int version) throws IOException
public void serialize(ReadTxnData read, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(read.txnId, out, version);
KeySerializers.participants.serialize(read.scope, out, version);
CommandSerializers.txnId.serialize(read.txnId, out);
KeySerializers.participants.serialize(read.scope, out);
out.writeUnsignedVInt(read.executeAtEpoch);
}
@Override
public ReadTxnData deserialize(DataInputPlus in, int version) throws IOException
public ReadTxnData deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> scope = KeySerializers.participants.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> scope = KeySerializers.participants.deserialize(in);
long executeAtEpoch = in.readUnsignedVInt();
return ReadTxnData.SerializerSupport.create(txnId, scope, executeAtEpoch);
}
@Override
public long serializedSize(ReadTxnData read, int version)
public long serializedSize(ReadTxnData read, Version version)
{
return CommandSerializers.txnId.serializedSize(read.txnId, version)
+ KeySerializers.participants.serializedSize(read.scope, version)
return CommandSerializers.txnId.serializedSize(read.txnId)
+ KeySerializers.participants.serializedSize(read.scope)
+ TypeSizes.sizeofUnsignedVInt(read.executeAtEpoch);
}
};
@ -158,45 +158,45 @@ public class ReadDataSerializers
public static final ReadDataSerializer<ReadEphemeralTxnData> readEphemeralTxnData = new ReadDataSerializer<>()
{
@Override
public void serialize(ReadEphemeralTxnData read, DataOutputPlus out, int version) throws IOException
public void serialize(ReadEphemeralTxnData read, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(read.txnId, out, version);
KeySerializers.participants.serialize(read.scope, out, version);
CommandSerializers.txnId.serialize(read.txnId, out);
KeySerializers.participants.serialize(read.scope, out);
out.writeUnsignedVInt(read.executeAtEpoch);
CommandSerializers.partialTxn.serialize(read.partialTxn(), out, version);
DepsSerializers.partialDeps.serialize(read.partialDeps(), out, version);
KeySerializers.fullRoute.serialize(read.route(), out, version);
DepsSerializers.partialDeps.serialize(read.partialDeps(), out);
KeySerializers.fullRoute.serialize(read.route(), out);
}
@Override
public ReadEphemeralTxnData deserialize(DataInputPlus in, int version) throws IOException
public ReadEphemeralTxnData deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> scope = KeySerializers.participants.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> scope = KeySerializers.participants.deserialize(in);
long executeAtEpoch = in.readUnsignedVInt();
PartialTxn partialTxn = CommandSerializers.partialTxn.deserialize(in, version);
PartialDeps partialDeps = DepsSerializers.partialDeps.deserialize(in, version);
FullRoute<?> route = KeySerializers.fullRoute.deserialize(in, version);
PartialDeps partialDeps = DepsSerializers.partialDeps.deserialize(in);
FullRoute<?> route = KeySerializers.fullRoute.deserialize(in);
return ReadEphemeralTxnData.SerializerSupport.create(txnId, scope, executeAtEpoch, partialTxn, partialDeps, route);
}
@Override
public long serializedSize(ReadEphemeralTxnData read, int version)
public long serializedSize(ReadEphemeralTxnData read, Version version)
{
return CommandSerializers.txnId.serializedSize(read.txnId, version)
+ KeySerializers.participants.serializedSize(read.scope, version)
return CommandSerializers.txnId.serializedSize(read.txnId)
+ KeySerializers.participants.serializedSize(read.scope)
+ TypeSizes.sizeofUnsignedVInt(read.executeAtEpoch)
+ CommandSerializers.partialTxn.serializedSize(read.partialTxn(), version)
+ DepsSerializers.partialDeps.serializedSize(read.partialDeps(), version)
+ KeySerializers.fullRoute.serializedSize(read.route(), version);
+ DepsSerializers.partialDeps.serializedSize(read.partialDeps())
+ KeySerializers.fullRoute.serializedSize(read.route());
}
};
public interface ReadDataSerializer<T extends ReadData> extends IVersionedSerializer<T>
{
void serialize(T bound, DataOutputPlus out, int version) throws IOException;
T deserialize(DataInputPlus in, int version) throws IOException;
long serializedSize(T condition, int version);
void serialize(T bound, DataOutputPlus out, Version version) throws IOException;
T deserialize(DataInputPlus in, Version version) throws IOException;
long serializedSize(T condition, Version version);
}
private static ReadDataSerializer serializerFor(ReadData toSerialize)
@ -225,15 +225,15 @@ public class ReadDataSerializers
{
// TODO (expected): use something other than ordinal
final CommitOrReadNack[] nacks = CommitOrReadNack.values();
private final IVersionedSerializer<D> dataSerializer;
private final VersionedSerializer<D, Version> dataSerializer;
public ReplySerializer(IVersionedSerializer<D> dataSerializer)
public ReplySerializer(VersionedSerializer<D, Version> dataSerializer)
{
this.dataSerializer = dataSerializer;
}
@Override
public void serialize(ReadReply reply, DataOutputPlus out, int version) throws IOException
public void serialize(ReadReply reply, DataOutputPlus out, Version version) throws IOException
{
if (!reply.isOk())
{
@ -244,7 +244,7 @@ public class ReadDataSerializers
ReadOk readOk = (ReadOk) reply;
int flags = readOk.getClass() == ReadOkWithFutureEpoch.class ? 2 : readOk.uniqueHlc != 0 ? 1 : 0;
out.writeByte(flags);
serializeNullable(readOk.unavailable, out, version, KeySerializers.ranges);
serializeNullable(readOk.unavailable, out, KeySerializers.ranges);
dataSerializer.serialize((D) readOk.data, out, version);
switch (flags)
{
@ -254,13 +254,13 @@ public class ReadDataSerializers
}
@Override
public ReadReply deserialize(DataInputPlus in, int version) throws IOException
public ReadReply deserialize(DataInputPlus in, Version version) throws IOException
{
int flags = in.readByte();
if (flags > 2)
return nacks[flags - 3];
Ranges unavailable = deserializeNullable(in, version, KeySerializers.ranges);
Ranges unavailable = deserializeNullable(in, KeySerializers.ranges);
D data = dataSerializer.deserialize(in, version);
long extraLong = flags == 0 ? 0 : in.readUnsignedVInt();
@ -270,14 +270,14 @@ public class ReadDataSerializers
}
@Override
public long serializedSize(ReadReply reply, int version)
public long serializedSize(ReadReply reply, Version version)
{
if (!reply.isOk())
return TypeSizes.BYTE_SIZE;
ReadOk readOk = (ReadOk) reply;
long size = TypeSizes.BYTE_SIZE
+ serializedNullableSize(readOk.unavailable, version, KeySerializers.ranges)
+ serializedNullableSize(readOk.unavailable, KeySerializers.ranges)
+ dataSerializer.serializedSize((D) readOk.data, version);
if (readOk.uniqueHlc != 0)
size += TypeSizes.sizeofUnsignedVInt(readOk.uniqueHlc);
@ -293,29 +293,29 @@ public class ReadDataSerializers
public static final ReadDataSerializer<WaitUntilApplied> waitUntilApplied = new ReadDataSerializer<WaitUntilApplied>()
{
@Override
public void serialize(WaitUntilApplied waitUntilApplied, DataOutputPlus out, int version) throws IOException
public void serialize(WaitUntilApplied waitUntilApplied, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(waitUntilApplied.txnId, out, version);
KeySerializers.participants.serialize(waitUntilApplied.scope, out, version);
CommandSerializers.txnId.serialize(waitUntilApplied.txnId, out);
KeySerializers.participants.serialize(waitUntilApplied.scope, out);
out.writeUnsignedVInt(waitUntilApplied.minEpoch());
out.writeUnsignedVInt(waitUntilApplied.executeAtEpoch - waitUntilApplied.minEpoch());
}
@Override
public WaitUntilApplied deserialize(DataInputPlus in, int version) throws IOException
public WaitUntilApplied deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> scope = KeySerializers.participants.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> scope = KeySerializers.participants.deserialize(in);
long minEpoch = in.readUnsignedVInt();
long executeAtEpoch = minEpoch + in.readUnsignedVInt();
return WaitUntilApplied.SerializerSupport.create(txnId, scope, minEpoch, executeAtEpoch);
}
@Override
public long serializedSize(WaitUntilApplied waitUntilApplied, int version)
public long serializedSize(WaitUntilApplied waitUntilApplied, Version version)
{
return CommandSerializers.txnId.serializedSize(waitUntilApplied.txnId, version)
+ KeySerializers.participants.serializedSize(waitUntilApplied.scope, version)
return CommandSerializers.txnId.serializedSize(waitUntilApplied.txnId)
+ KeySerializers.participants.serializedSize(waitUntilApplied.scope)
+ TypeSizes.sizeofUnsignedVInt(waitUntilApplied.minEpoch())
+ TypeSizes.sizeofUnsignedVInt(waitUntilApplied.executeAtEpoch - waitUntilApplied.minEpoch());
}
@ -325,46 +325,46 @@ public class ReadDataSerializers
public static final ReadDataSerializer<StableThenRead> stableThenRead = new ReadDataSerializer<>()
{
@Override
public void serialize(StableThenRead read, DataOutputPlus out, int version) throws IOException
public void serialize(StableThenRead read, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(read.txnId, out, version);
KeySerializers.participants.serialize(read.scope, out, version);
CommitSerializers.kind.serialize(read.kind, out, version);
CommandSerializers.txnId.serialize(read.txnId, out);
KeySerializers.participants.serialize(read.scope, out);
CommitSerializers.kind.serialize(read.kind, out);
out.writeUnsignedVInt(read.minEpoch);
ExecuteAtSerializer.serialize(read.txnId, read.executeAt, out);
if (read.kind.withTxn != NoTxn)
CommandSerializers.nullablePartialTxn.serialize(read.partialTxn, out, version);
if (read.kind.withDeps == HasDeps)
DepsSerializers.partialDeps.serialize(read.partialDeps, out, version);
DepsSerializers.partialDeps.serialize(read.partialDeps, out);
if (read.kind.withTxn == HasTxn)
KeySerializers.fullRoute.serialize(read.route, out, version);
KeySerializers.fullRoute.serialize(read.route, out);
}
@Override
public StableThenRead deserialize(DataInputPlus in, int version) throws IOException
public StableThenRead deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Participants<?> scope = KeySerializers.participants.deserialize(in, version);
Commit.Kind kind = CommitSerializers.kind.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Participants<?> scope = KeySerializers.participants.deserialize(in);
Commit.Kind kind = CommitSerializers.kind.deserialize(in);
long minEpoch = in.readUnsignedVInt();
Timestamp executeAt = ExecuteAtSerializer.deserialize(txnId, in);
PartialTxn partialTxn = kind.withTxn == NoTxn ? null : CommandSerializers.nullablePartialTxn.deserialize(in, version);
PartialDeps partialDeps = kind.withDeps == NoDeps ? null : DepsSerializers.partialDeps.deserialize(in, version);
FullRoute < ?> route = kind.withTxn == HasTxn ? KeySerializers.fullRoute.deserialize(in, version) : null;
PartialDeps partialDeps = kind.withDeps == NoDeps ? null : DepsSerializers.partialDeps.deserialize(in);
FullRoute < ?> route = kind.withTxn == HasTxn ? KeySerializers.fullRoute.deserialize(in) : null;
return StableThenRead.SerializerSupport.create(txnId, scope, kind, minEpoch, executeAt, partialTxn, partialDeps, route);
}
@Override
public long serializedSize(StableThenRead read, int version)
public long serializedSize(StableThenRead read, Version version)
{
return CommandSerializers.txnId.serializedSize(read.txnId, version)
+ KeySerializers.participants.serializedSize(read.scope, version)
+ CommitSerializers.kind.serializedSize(read.kind, version)
return CommandSerializers.txnId.serializedSize(read.txnId)
+ KeySerializers.participants.serializedSize(read.scope)
+ CommitSerializers.kind.serializedSize(read.kind)
+ TypeSizes.sizeofUnsignedVInt(read.minEpoch)
+ ExecuteAtSerializer.serializedSize(read.txnId, read.executeAt)
+ (read.kind.withTxn == NoTxn ? 0 : CommandSerializers.nullablePartialTxn.serializedSize(read.partialTxn, version))
+ (read.kind.withDeps != HasDeps ? 0 : DepsSerializers.partialDeps.serializedSize(read.partialDeps, version))
+ (read.kind.withTxn != HasTxn ? 0 : KeySerializers.fullRoute.serializedSize(read.route, version));
+ (read.kind.withDeps != HasDeps ? 0 : DepsSerializers.partialDeps.serializedSize(read.partialDeps))
+ (read.kind.withTxn != HasTxn ? 0 : KeySerializers.fullRoute.serializedSize(read.route));
}
};
}

140
src/java/org/apache/cassandra/service/accord/serializers/RecoverySerializers.java
View File

@ -41,7 +41,7 @@ import accord.primitives.Timestamp;
import accord.primitives.TxnId;
import accord.primitives.Writes;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
@ -57,30 +57,30 @@ public class RecoverySerializers
public static final IVersionedSerializer<BeginRecovery> request = new WithUnsyncedSerializer<BeginRecovery>()
{
@Override
public void serializeBody(BeginRecovery recover, DataOutputPlus out, int version) throws IOException
public void serializeBody(BeginRecovery recover, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.partialTxn.serialize(recover.partialTxn, out, version);
CommandSerializers.ballot.serialize(recover.ballot, out, version);
serializeNullable(recover.route, out, version, KeySerializers.fullRoute);
CommandSerializers.ballot.serialize(recover.ballot, out);
serializeNullable(recover.route, out, KeySerializers.fullRoute);
out.writeUnsignedVInt(recover.executeAtOrTxnIdEpoch - recover.txnId.epoch());
}
@Override
public BeginRecovery deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
public BeginRecovery deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException
{
PartialTxn partialTxn = CommandSerializers.partialTxn.deserialize(in, version);
Ballot ballot = CommandSerializers.ballot.deserialize(in, version);
@Nullable FullRoute<?> route = deserializeNullable(in, version, KeySerializers.fullRoute);
Ballot ballot = CommandSerializers.ballot.deserialize(in);
@Nullable FullRoute<?> route = deserializeNullable(in, KeySerializers.fullRoute);
long executeAtOrTxnIdEpoch = in.readUnsignedVInt32() + txnId.epoch();
return BeginRecovery.SerializationSupport.create(txnId, scope, waitForEpoch, minEpoch, partialTxn, ballot, route, executeAtOrTxnIdEpoch);
}
@Override
public long serializedBodySize(BeginRecovery recover, int version)
public long serializedBodySize(BeginRecovery recover, Version version)
{
return CommandSerializers.partialTxn.serializedSize(recover.partialTxn, version)
+ CommandSerializers.ballot.serializedSize(recover.ballot, version)
+ serializedNullableSize(recover.route, version, KeySerializers.fullRoute)
+ CommandSerializers.ballot.serializedSize(recover.ballot)
+ serializedNullableSize(recover.route, KeySerializers.fullRoute)
+ TypeSizes.sizeofUnsignedVInt(recover.executeAtOrTxnIdEpoch - recover.txnId.epoch());
}
};
@ -88,54 +88,54 @@ public class RecoverySerializers
public static final IVersionedSerializer<RecoverReply> reply = new IVersionedSerializer<RecoverReply>()
{
final RecoverReply.Kind[] kinds = RecoverReply.Kind.values();
void serializeNack(RecoverNack recoverNack, DataOutputPlus out, int version) throws IOException
void serializeNack(RecoverNack recoverNack, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.ballot.serialize(recoverNack.supersededBy, out, version);
CommandSerializers.ballot.serialize(recoverNack.supersededBy, out);
}
void serializeOk(RecoverOk recoverOk, DataOutputPlus out, int version) throws IOException
void serializeOk(RecoverOk recoverOk, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(recoverOk.txnId, out, version);
CommandSerializers.status.serialize(recoverOk.status, out, version);
CommandSerializers.ballot.serialize(recoverOk.accepted, out, version);
CommandSerializers.txnId.serialize(recoverOk.txnId, out);
CommandSerializers.status.serialize(recoverOk.status, out);
CommandSerializers.ballot.serialize(recoverOk.accepted, out);
ExecuteAtSerializer.serializeNullable(recoverOk.executeAt, out);
latestDeps.serialize(recoverOk.deps, out, version);
DepsSerializers.deps.serialize(recoverOk.earlierWait, out, version);
DepsSerializers.deps.serialize(recoverOk.earlierNoWait, out, version);
DepsSerializers.deps.serialize(recoverOk.laterCoordRejects, out, version);
latestDeps.serialize(recoverOk.deps, out);
DepsSerializers.deps.serialize(recoverOk.earlierWait, out);
DepsSerializers.deps.serialize(recoverOk.earlierNoWait, out);
DepsSerializers.deps.serialize(recoverOk.laterCoordRejects, out);
out.writeBoolean(recoverOk.selfAcceptsFastPath);
KeySerializers.nullableParticipants.serialize(recoverOk.coordinatorAcceptsFastPath, out, version);
KeySerializers.nullableParticipants.serialize(recoverOk.coordinatorAcceptsFastPath, out);
out.writeBoolean(recoverOk.supersedingRejects);
CommandSerializers.nullableWrites.serialize(recoverOk.writes, out, version);
}
@Override
public void serialize(RecoverReply reply, DataOutputPlus out, int version) throws IOException
public void serialize(RecoverReply reply, DataOutputPlus out, Version version) throws IOException
{
out.writeByte(reply.kind().ordinal());
if (reply.kind() == Ok) serializeOk((RecoverOk) reply, out, version);
else serializeNack((RecoverNack) reply, out, version);
}
RecoverNack deserializeNack(RecoverReply.Kind kind, Ballot supersededBy, DataInputPlus in, int version)
RecoverNack deserializeNack(RecoverReply.Kind kind, Ballot supersededBy, DataInputPlus in, Version version)
{
return new RecoverNack(kind, supersededBy);
}
RecoverOk deserializeOk(TxnId txnId, Status status, Ballot accepted, Timestamp executeAt, @Nonnull LatestDeps deps, Deps earlierWait, Deps earlierNoWait, Deps laterCoordRejects, boolean acceptsFastPath, @Nullable Participants<?> coordinatorAcceptsFastPath, boolean rejectsFastPath, Writes writes, Result result, DataInputPlus in, int version)
RecoverOk deserializeOk(TxnId txnId, Status status, Ballot accepted, Timestamp executeAt, @Nonnull LatestDeps deps, Deps earlierWait, Deps earlierNoWait, Deps laterCoordRejects, boolean acceptsFastPath, @Nullable Participants<?> coordinatorAcceptsFastPath, boolean rejectsFastPath, Writes writes, Result result, DataInputPlus in, Version version)
{
return new RecoverOk(txnId, status, accepted, executeAt, deps, earlierWait, earlierNoWait, laterCoordRejects, acceptsFastPath, coordinatorAcceptsFastPath, rejectsFastPath, writes, result);
}
@Override
public RecoverReply deserialize(DataInputPlus in, int version) throws IOException
public RecoverReply deserialize(DataInputPlus in, Version version) throws IOException
{
RecoverReply.Kind kind = kinds[in.readByte()];
if (kind != Ok)
return deserializeNack(kind, CommandSerializers.ballot.deserialize(in, version), in, version);
return deserializeNack(kind, CommandSerializers.ballot.deserialize(in), in, version);
TxnId id = CommandSerializers.txnId.deserialize(in, version);
Status status = CommandSerializers.status.deserialize(in, version);
TxnId id = CommandSerializers.txnId.deserialize(in);
Status status = CommandSerializers.status.deserialize(in);
Result result = null;
if (status == Status.PreApplied || status == Status.Applied || status == Status.Truncated)
@ -143,14 +143,14 @@ public class RecoverySerializers
return deserializeOk(id,
status,
CommandSerializers.ballot.deserialize(in, version),
CommandSerializers.ballot.deserialize(in),
ExecuteAtSerializer.deserializeNullable(in),
latestDeps.deserialize(in, version),
DepsSerializers.deps.deserialize(in, version),
DepsSerializers.deps.deserialize(in, version),
DepsSerializers.deps.deserialize(in, version),
latestDeps.deserialize(in),
DepsSerializers.deps.deserialize(in),
DepsSerializers.deps.deserialize(in),
DepsSerializers.deps.deserialize(in),
in.readBoolean(),
KeySerializers.nullableParticipants.deserialize(in, version),
KeySerializers.nullableParticipants.deserialize(in),
in.readBoolean(),
CommandSerializers.nullableWrites.deserialize(in, version),
result,
@ -158,108 +158,108 @@ public class RecoverySerializers
version);
}
long serializedNackSize(RecoverNack recoverNack, int version)
long serializedNackSize(RecoverNack recoverNack, Version version)
{
return CommandSerializers.ballot.serializedSize(recoverNack.supersededBy, version);
return CommandSerializers.ballot.serializedSize(recoverNack.supersededBy);
}
long serializedOkSize(RecoverOk recoverOk, int version)
long serializedOkSize(RecoverOk recoverOk, Version version)
{
long size = CommandSerializers.txnId.serializedSize(recoverOk.txnId, version);
size += CommandSerializers.status.serializedSize(recoverOk.status, version);
size += CommandSerializers.ballot.serializedSize(recoverOk.accepted, version);
long size = CommandSerializers.txnId.serializedSize(recoverOk.txnId);
size += CommandSerializers.status.serializedSize(recoverOk.status);
size += CommandSerializers.ballot.serializedSize(recoverOk.accepted);
size += ExecuteAtSerializer.serializedNullableSize(recoverOk.executeAt);
size += latestDeps.serializedSize(recoverOk.deps, version);
size += DepsSerializers.deps.serializedSize(recoverOk.earlierWait, version);
size += DepsSerializers.deps.serializedSize(recoverOk.earlierNoWait, version);
size += DepsSerializers.deps.serializedSize(recoverOk.laterCoordRejects, version);
size += latestDeps.serializedSize(recoverOk.deps);
size += DepsSerializers.deps.serializedSize(recoverOk.earlierWait);
size += DepsSerializers.deps.serializedSize(recoverOk.earlierNoWait);
size += DepsSerializers.deps.serializedSize(recoverOk.laterCoordRejects);
size += TypeSizes.sizeof(recoverOk.selfAcceptsFastPath);
size += KeySerializers.nullableParticipants.serializedSize(recoverOk.coordinatorAcceptsFastPath, version);
size += KeySerializers.nullableParticipants.serializedSize(recoverOk.coordinatorAcceptsFastPath);
size += TypeSizes.sizeof(recoverOk.supersedingRejects);
size += CommandSerializers.nullableWrites.serializedSize(recoverOk.writes, version);
return size;
}
@Override
public long serializedSize(RecoverReply reply, int version)
public long serializedSize(RecoverReply reply, Version version)
{
return TypeSizes.BYTE_SIZE
+ (reply.kind() == Ok ? serializedOkSize((RecoverOk) reply, version) : serializedNackSize((RecoverNack) reply, version));
}
};
public static final IVersionedSerializer<LatestDeps> latestDeps = new IVersionedSerializer<>()
public static final UnversionedSerializer<LatestDeps> latestDeps = new UnversionedSerializer<>()
{
@Override
public void serialize(LatestDeps t, DataOutputPlus out, int version) throws IOException
public void serialize(LatestDeps t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(t.size());
for (int i = 0 ; i < t.size() ; ++i)
{
RoutingKey start = t.startAt(i);
KeySerializers.routingKey.serialize(start, out, version);
KeySerializers.routingKey.serialize(start, out);
LatestDeps.LatestEntry e = t.valueAt(i);
if (e == null)
{
CommandSerializers.knownDeps.serialize(null, out, version);
CommandSerializers.knownDeps.serialize(null, out);
}
else
{
CommandSerializers.knownDeps.serialize(e.known, out, version);
CommandSerializers.ballot.serialize(e.ballot, out, version);
DepsSerializers.nullableDeps.serialize(e.coordinatedDeps, out, version);
DepsSerializers.nullableDeps.serialize(e.localDeps, out, version);
CommandSerializers.knownDeps.serialize(e.known, out);
CommandSerializers.ballot.serialize(e.ballot, out);
DepsSerializers.nullableDeps.serialize(e.coordinatedDeps, out);
DepsSerializers.nullableDeps.serialize(e.localDeps, out);
}
}
KeySerializers.routingKey.serialize(t.startAt(t.size()), out, version);
KeySerializers.routingKey.serialize(t.startAt(t.size()), out);
}
@Override
public LatestDeps deserialize(DataInputPlus in, int version) throws IOException
public LatestDeps deserialize(DataInputPlus in) throws IOException
{
int size = in.readUnsignedVInt32();
RoutingKey[] starts = new RoutingKey[size + 1];
LatestDeps.LatestEntry[] values = new LatestDeps.LatestEntry[size];
for (int i = 0 ; i < size ; ++i)
{
starts[i] = KeySerializers.routingKey.deserialize(in, version);
KnownDeps knownDeps = CommandSerializers.knownDeps.deserialize(in, version);
starts[i] = KeySerializers.routingKey.deserialize(in);
KnownDeps knownDeps = CommandSerializers.knownDeps.deserialize(in);
if (knownDeps == null)
continue;
Ballot ballot = CommandSerializers.ballot.deserialize(in, version);
Deps coordinatedDeps = DepsSerializers.nullableDeps.deserialize(in, version);
Deps localDeps = DepsSerializers.nullableDeps.deserialize(in, version);
Ballot ballot = CommandSerializers.ballot.deserialize(in);
Deps coordinatedDeps = DepsSerializers.nullableDeps.deserialize(in);
Deps localDeps = DepsSerializers.nullableDeps.deserialize(in);
values[i] = new LatestDeps.LatestEntry(knownDeps, ballot, coordinatedDeps, localDeps);
}
starts[size] = KeySerializers.routingKey.deserialize(in, version);
starts[size] = KeySerializers.routingKey.deserialize(in);
return LatestDeps.SerializerSupport.create(true, starts, values);
}
@Override
public long serializedSize(LatestDeps t, int version)
public long serializedSize(LatestDeps t)
{
long size = 0;
size += TypeSizes.sizeofUnsignedVInt(t.size());
for (int i = 0 ; i < t.size() ; ++i)
{
RoutingKey start = t.startAt(i);
size += KeySerializers.routingKey.serializedSize(start, version);
size += KeySerializers.routingKey.serializedSize(start);
LatestDeps.LatestEntry e = t.valueAt(i);
if (e == null)
{
size += CommandSerializers.knownDeps.serializedSize(null, version);
size += CommandSerializers.knownDeps.serializedSize(null);
}
else
{
size += CommandSerializers.knownDeps.serializedSize(e.known, version);
size += CommandSerializers.ballot.serializedSize(e.ballot, version);
size += DepsSerializers.nullableDeps.serializedSize(e.coordinatedDeps, version);
size += DepsSerializers.nullableDeps.serializedSize(e.localDeps, version);
size += CommandSerializers.knownDeps.serializedSize(e.known);
size += CommandSerializers.ballot.serializedSize(e.ballot);
size += DepsSerializers.nullableDeps.serializedSize(e.coordinatedDeps);
size += DepsSerializers.nullableDeps.serializedSize(e.localDeps);
}
}
size += KeySerializers.routingKey.serializedSize(t.startAt(t.size()), version);
size += KeySerializers.routingKey.serializedSize(t.startAt(t.size()));
return size;
}
};

10
src/java/org/apache/cassandra/service/accord/serializers/ResultSerializers.java
View File

@ -20,7 +20,7 @@ package org.apache.cassandra.service.accord.serializers;
import accord.api.Result;
import accord.primitives.ProgressToken;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
@ -36,15 +36,15 @@ public class ResultSerializers
}
};
public static final IVersionedSerializer<Result> result = new IVersionedSerializer<>()
public static final UnversionedSerializer<Result> result = new UnversionedSerializer<>()
{
public void serialize(Result t, DataOutputPlus out, int version) { }
public Result deserialize(DataInputPlus in, int version)
public void serialize(Result t, DataOutputPlus out) { }
public Result deserialize(DataInputPlus in)
{
return APPLIED;
}
public long serializedSize(Result t, int version)
public long serializedSize(Result t)
{
return 0;
}

62
src/java/org/apache/cassandra/service/accord/serializers/SetDurableSerializers.java
View File

@ -26,86 +26,86 @@ import accord.primitives.FullRoute;
import accord.primitives.SyncPoint;
import accord.primitives.Timestamp;
import accord.primitives.TxnId;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.CommandSerializers.ExecuteAtSerializer;
public class SetDurableSerializers
{
public static final IVersionedSerializer<SetShardDurable> shardDurable = new IVersionedSerializer<>()
public static final UnversionedSerializer<SetShardDurable> shardDurable = new UnversionedSerializer<>()
{
@Override
public void serialize(SetShardDurable msg, DataOutputPlus out, int version) throws IOException
public void serialize(SetShardDurable msg, DataOutputPlus out) throws IOException
{
syncPoint.serialize(msg.exclusiveSyncPoint, out, version);
CommandSerializers.durability.serialize(msg.durability, out, version);
syncPoint.serialize(msg.exclusiveSyncPoint, out);
CommandSerializers.durability.serialize(msg.durability, out);
}
@Override
public SetShardDurable deserialize(DataInputPlus in, int version) throws IOException
public SetShardDurable deserialize(DataInputPlus in) throws IOException
{
return new SetShardDurable(syncPoint.deserialize(in, version),
CommandSerializers.durability.deserialize(in, version));
return new SetShardDurable(syncPoint.deserialize(in),
CommandSerializers.durability.deserialize(in));
}
@Override
public long serializedSize(SetShardDurable msg, int version)
public long serializedSize(SetShardDurable msg)
{
return syncPoint.serializedSize(msg.exclusiveSyncPoint, version)
+ CommandSerializers.durability.serializedSize(msg.durability, version);
return syncPoint.serializedSize(msg.exclusiveSyncPoint)
+ CommandSerializers.durability.serializedSize(msg.durability);
}
};
public static final IVersionedSerializer<SetGloballyDurable> globallyDurable = new IVersionedSerializer<>()
public static final UnversionedSerializer<SetGloballyDurable> globallyDurable = new UnversionedSerializer<>()
{
@Override
public void serialize(SetGloballyDurable msg, DataOutputPlus out, int version) throws IOException
public void serialize(SetGloballyDurable msg, DataOutputPlus out) throws IOException
{
CommandStoreSerializers.durableBefore.serialize(msg.durableBefore, out, version);
CommandStoreSerializers.durableBefore.serialize(msg.durableBefore, out);
}
@Override
public SetGloballyDurable deserialize(DataInputPlus in, int version) throws IOException
public SetGloballyDurable deserialize(DataInputPlus in) throws IOException
{
return new SetGloballyDurable(CommandStoreSerializers.durableBefore.deserialize(in, version));
return new SetGloballyDurable(CommandStoreSerializers.durableBefore.deserialize(in));
}
@Override
public long serializedSize(SetGloballyDurable msg, int version)
public long serializedSize(SetGloballyDurable msg)
{
return CommandStoreSerializers.durableBefore.serializedSize(msg.durableBefore, version);
return CommandStoreSerializers.durableBefore.serializedSize(msg.durableBefore);
}
};
public static final IVersionedSerializer<SyncPoint> syncPoint = new IVersionedSerializer<>()
public static final UnversionedSerializer<SyncPoint> syncPoint = new UnversionedSerializer<>()
{
@Override
public void serialize(SyncPoint sp, DataOutputPlus out, int version) throws IOException
public void serialize(SyncPoint sp, DataOutputPlus out) throws IOException
{
CommandSerializers.txnId.serialize(sp.syncId, out, version);
CommandSerializers.txnId.serialize(sp.syncId, out);
ExecuteAtSerializer.serialize(sp.syncId, sp.executeAt, out);
DepsSerializers.deps.serialize(sp.waitFor, out, version);
KeySerializers.fullRoute.serialize(sp.route, out, version);
DepsSerializers.deps.serialize(sp.waitFor, out);
KeySerializers.fullRoute.serialize(sp.route, out);
}
@Override
public SyncPoint deserialize(DataInputPlus in, int version) throws IOException
public SyncPoint deserialize(DataInputPlus in) throws IOException
{
TxnId syncId = CommandSerializers.txnId.deserialize(in, version);
TxnId syncId = CommandSerializers.txnId.deserialize(in);
Timestamp executeAt = ExecuteAtSerializer.deserialize(syncId, in);
Deps waitFor = DepsSerializers.deps.deserialize(in, version);
FullRoute<?> route = KeySerializers.fullRoute.deserialize(in, version);
Deps waitFor = DepsSerializers.deps.deserialize(in);
FullRoute<?> route = KeySerializers.fullRoute.deserialize(in);
return SyncPoint.SerializationSupport.construct(syncId, executeAt, waitFor, route);
}
@Override
public long serializedSize(SyncPoint sp, int version)
public long serializedSize(SyncPoint sp)
{
return CommandSerializers.txnId.serializedSize(sp.syncId, version)
return CommandSerializers.txnId.serializedSize(sp.syncId)
+ ExecuteAtSerializer.serializedSize(sp.syncId, sp.executeAt)
+ DepsSerializers.deps.serializedSize(sp.waitFor, version)
+ KeySerializers.fullRoute.serializedSize(sp.route, version);
+ DepsSerializers.deps.serializedSize(sp.waitFor)
+ KeySerializers.fullRoute.serializedSize(sp.route);
}
};
}

117
src/java/org/apache/cassandra/service/accord/serializers/TopologySerializers.java
View File

@ -29,12 +29,10 @@ import accord.utils.SortedArrays.SortedArrayList;
import accord.utils.TinyEnumSet;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.db.marshal.ValueAccessor;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.TokenRange;
import org.apache.cassandra.tcm.serialization.MetadataSerializer;
import org.apache.cassandra.tcm.serialization.Version;
import org.apache.cassandra.utils.ArraySerializers;
import org.apache.cassandra.utils.CollectionSerializers;
@ -43,27 +41,16 @@ public class TopologySerializers
private TopologySerializers() {}
public static final NodeIdSerializer nodeId = new NodeIdSerializer();
public static class NodeIdSerializer implements IVersionedSerializer<Node.Id>, MetadataSerializer<Node.Id>
public static class NodeIdSerializer implements UnversionedSerializer<Node.Id>
{
private NodeIdSerializer() {}
public static void serialize(Node.Id id, DataOutputPlus out) throws IOException
@Override
public void serialize(Node.Id id, DataOutputPlus out) throws IOException
{
out.writeInt(id.id);
}
@Override
public void serialize(Node.Id id, DataOutputPlus out, int version) throws IOException
{
serialize(id, out);
}
@Override
public void serialize(Node.Id id, DataOutputPlus out, Version version) throws IOException
{
serialize(id, out);
}
public <V> int serialize(Node.Id id, V dst, ValueAccessor<V> accessor, int offset)
{
return accessor.putInt(dst, offset, id.id);
@ -74,23 +61,12 @@ public class TopologySerializers
out.putInt(id.id);
}
public static Node.Id deserialize(DataInputPlus in) throws IOException
@Override
public Node.Id deserialize(DataInputPlus in) throws IOException
{
return new Node.Id(in.readInt());
}
@Override
public Node.Id deserialize(DataInputPlus in, int version) throws IOException
{
return deserialize(in);
}
@Override
public Node.Id deserialize(DataInputPlus in, Version version) throws IOException
{
return deserialize(in);
}
public <V> Node.Id deserialize(V src, ValueAccessor<V> accessor, int offset)
{
return new Node.Id(accessor.getInt(src, offset));
@ -101,96 +77,85 @@ public class TopologySerializers
return new Node.Id(src.getInt(position));
}
public int serializedSize()
@Override
public long serializedSize(Node.Id id)
{
return TypeSizes.INT_SIZE; // id.id
}
}
@Override
public long serializedSize(Node.Id id, int version)
{
return serializedSize();
}
public static final UnversionedSerializer<Shard> shard = new ShardSerializer((UnversionedSerializer<Range>)
(UnversionedSerializer<?>)
TokenRange.serializer);
@Override
public long serializedSize(Node.Id t, Version version)
{
return serializedSize();
}
};
public static final IVersionedSerializer<Shard> shard = new ShardSerializer((IVersionedSerializer<Range>)
(IVersionedSerializer<?>)
TokenRange.serializer);
public static class ShardSerializer implements IVersionedSerializer<Shard>
public static class ShardSerializer implements UnversionedSerializer<Shard>
{
protected IVersionedSerializer<Range> range;
protected UnversionedSerializer<Range> range;
public ShardSerializer(IVersionedSerializer<Range> range)
public ShardSerializer(UnversionedSerializer<Range> range)
{
this.range = range;
}
@Override
public void serialize(Shard shard, DataOutputPlus out, int version) throws IOException
public void serialize(Shard shard, DataOutputPlus out) throws IOException
{
range.serialize(shard.range, out, version);
CollectionSerializers.serializeList(shard.nodes, out, version, nodeId);
CollectionSerializers.serializeList(shard.notInFastPath, out, version, nodeId);
CollectionSerializers.serializeList(shard.joining, out, version, nodeId);
range.serialize(shard.range, out);
CollectionSerializers.serializeList(shard.nodes, out, nodeId);
CollectionSerializers.serializeList(shard.notInFastPath, out, nodeId);
CollectionSerializers.serializeList(shard.joining, out, nodeId);
out.writeUnsignedVInt32(shard.flags().bitset());
}
@Override
public Shard deserialize(DataInputPlus in, int version) throws IOException
public Shard deserialize(DataInputPlus in) throws IOException
{
Range range = ShardSerializer.this.range.deserialize(in, version);
SortedArrayList<Node.Id> nodes = CollectionSerializers.deserializeSortedArrayList(in, version, nodeId, Node.Id[]::new);
SortedArrayList<Node.Id> notInFastPath = CollectionSerializers.deserializeSortedArrayList(in, version, nodeId, Node.Id[]::new);
SortedArrayList<Node.Id> joining = CollectionSerializers.deserializeSortedArrayList(in, version, nodeId, Node.Id[]::new);
Range range = ShardSerializer.this.range.deserialize(in);
SortedArrayList<Node.Id> nodes = CollectionSerializers.deserializeSortedArrayList(in, nodeId, Node.Id[]::new);
SortedArrayList<Node.Id> notInFastPath = CollectionSerializers.deserializeSortedArrayList(in, nodeId, Node.Id[]::new);
SortedArrayList<Node.Id> joining = CollectionSerializers.deserializeSortedArrayList(in, nodeId, Node.Id[]::new);
int flags = in.readUnsignedVInt32();
return Shard.SerializerSupport.create(range, nodes, notInFastPath, joining, new TinyEnumSet<>(flags));
}
@Override
public long serializedSize(Shard shard, int version)
public long serializedSize(Shard shard)
{
long size = range.serializedSize(shard.range, version);
size += CollectionSerializers.serializedListSize(shard.nodes, version, nodeId);
size += CollectionSerializers.serializedListSize(shard.notInFastPath, version, nodeId);
size += CollectionSerializers.serializedListSize(shard.joining, version, nodeId);
long size = range.serializedSize(shard.range);
size += CollectionSerializers.serializedListSize(shard.nodes, nodeId);
size += CollectionSerializers.serializedListSize(shard.notInFastPath, nodeId);
size += CollectionSerializers.serializedListSize(shard.joining, nodeId);
size += TypeSizes.sizeofUnsignedVInt(shard.flags().bitset());
return size;
}
};
}
public static final IVersionedSerializer<Topology> topology = new IVersionedSerializer<>()
public static final UnversionedSerializer<Topology> topology = new UnversionedSerializer<>()
{
@Override
public void serialize(Topology topology, DataOutputPlus out, int version) throws IOException
public void serialize(Topology topology, DataOutputPlus out) throws IOException
{
out.writeLong(topology.epoch());
ArraySerializers.serializeArray(topology.unsafeGetShards(), out, version, shard);
CollectionSerializers.serializeCollection(topology.staleIds(), out, version, TopologySerializers.nodeId);
CollectionSerializers.serializeList(topology.shards(), out, shard);
CollectionSerializers.serializeCollection(topology.staleIds(), out, TopologySerializers.nodeId);
}
@Override
public Topology deserialize(DataInputPlus in, int version) throws IOException
public Topology deserialize(DataInputPlus in) throws IOException
{
long epoch = in.readLong();
Shard[] shards = ArraySerializers.deserializeArray(in, version, shard, Shard[]::new);
SortedArrayList<Node.Id> staleIds = CollectionSerializers.deserializeSortedArrayList(in, version, TopologySerializers.nodeId, Node.Id[]::new);
Shard[] shards = ArraySerializers.deserializeArray(in, shard, Shard[]::new);
SortedArrayList<Node.Id> staleIds = CollectionSerializers.deserializeSortedArrayList(in, TopologySerializers.nodeId, Node.Id[]::new);
return new Topology(epoch, staleIds, shards);
}
@Override
public long serializedSize(Topology topology, int version)
public long serializedSize(Topology topology)
{
long size = 0;
size += TypeSizes.LONG_SIZE; // epoch
size += ArraySerializers.serializedArraySize(topology.unsafeGetShards(), version, shard);
size += CollectionSerializers.serializedCollectionSize(topology.staleIds(), version, TopologySerializers.nodeId);
size += CollectionSerializers.serializedListSize(topology.shards(), shard);
size += CollectionSerializers.serializedCollectionSize(topology.staleIds(), TopologySerializers.nodeId);
return size;
}
};

37
src/java/org/apache/cassandra/service/accord/serializers/TxnRequestSerializer.java
View File

@ -24,51 +24,50 @@ import accord.messages.TxnRequest;
import accord.primitives.Route;
import accord.primitives.TxnId;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public abstract class TxnRequestSerializer<T extends TxnRequest<?>> implements IVersionedSerializer<T>
{
void serializeHeader(T msg, DataOutputPlus out, int version) throws IOException
void serializeHeader(T msg, DataOutputPlus out, Version version) throws IOException
{
CommandSerializers.txnId.serialize(msg.txnId, out, version);
KeySerializers.route.serialize(msg.scope, out, version);
CommandSerializers.txnId.serialize(msg.txnId, out);
KeySerializers.route.serialize(msg.scope, out);
out.writeUnsignedVInt(msg.waitForEpoch);
}
public abstract void serializeBody(T msg, DataOutputPlus out, int version) throws IOException;
public abstract void serializeBody(T msg, DataOutputPlus out, Version version) throws IOException;
@Override
public final void serialize(T msg, DataOutputPlus out, int version) throws IOException
public final void serialize(T msg, DataOutputPlus out, Version version) throws IOException
{
serializeHeader(msg, out, version);
serializeBody(msg, out, version);
}
public abstract T deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch) throws IOException;
public abstract T deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch) throws IOException;
@Override
public final T deserialize(DataInputPlus in, int version) throws IOException
public final T deserialize(DataInputPlus in, Version version) throws IOException
{
TxnId txnId = CommandSerializers.txnId.deserialize(in, version);
Route<?> scope = KeySerializers.route.deserialize(in, version);
TxnId txnId = CommandSerializers.txnId.deserialize(in);
Route<?> scope = KeySerializers.route.deserialize(in);
// TODO: there should be a base epoch
long waitForEpoch = in.readUnsignedVInt();
return deserializeBody(in, version, txnId, scope, waitForEpoch);
}
long serializedHeaderSize(T msg, int version)
long serializedHeaderSize(T msg, Version version)
{
return CommandSerializers.txnId.serializedSize(msg.txnId, version)
+ KeySerializers.route.serializedSize(msg.scope(), version) +
return CommandSerializers.txnId.serializedSize(msg.txnId)
+ KeySerializers.route.serializedSize(msg.scope()) +
TypeSizes.sizeofUnsignedVInt(msg.waitForEpoch);
}
public abstract long serializedBodySize(T msg, int version);
public abstract long serializedBodySize(T msg, Version version);
@Override
public final long serializedSize(T msg, int version)
public final long serializedSize(T msg, Version version)
{
return serializedHeaderSize(msg, version) + serializedBodySize(msg, version);
}
@ -76,23 +75,23 @@ public abstract class TxnRequestSerializer<T extends TxnRequest<?>> implements I
public static abstract class WithUnsyncedSerializer<T extends TxnRequest.WithUnsynced<?>> extends TxnRequestSerializer<T>
{
@Override
void serializeHeader(T msg, DataOutputPlus out, int version) throws IOException
void serializeHeader(T msg, DataOutputPlus out, Version version) throws IOException
{
super.serializeHeader(msg, out, version);
out.writeUnsignedVInt(msg.minEpoch);
}
public abstract T deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException;
public abstract T deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch, long minEpoch) throws IOException;
@Override
public final T deserializeBody(DataInputPlus in, int version, TxnId txnId, Route<?> scope, long waitForEpoch) throws IOException
public final T deserializeBody(DataInputPlus in, Version version, TxnId txnId, Route<?> scope, long waitForEpoch) throws IOException
{
long minEpoch = in.readUnsignedVInt();
return deserializeBody(in, version, txnId, scope, waitForEpoch, minEpoch);
}
@Override
long serializedHeaderSize(T msg, int version)
long serializedHeaderSize(T msg, Version version)
{
long size = super.serializedHeaderSize(msg, version);
size += TypeSizes.sizeofUnsignedVInt(msg.minEpoch);

134
src/java/org/apache/cassandra/service/accord/serializers/Version.java Normal file
View File

@ -0,0 +1,134 @@
/*
* 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.apache.cassandra.service.accord.serializers;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.MessageVersionProvider;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.net.MessagingService;
public enum Version implements MessageVersionProvider
{
// If MessagingService version bumps, this mapping does not need to be updated; only updates needed are those that
// include accord serializer changes.
V1(1, MessagingService.Version.VERSION_51);
public static final Version LATEST = Version.V1;
/**
* Version that should be used for disk serialization where downgrade may be possible.
*
* As of this writing only 1 version exists, so this is the same as LATEST... Once v2 comes into the picture we need this version to be the oldest version needed for downgrade... If you upgrade from 5.1 to 5.2 (assuming this adds a v2) you need a version that works with 5.1 here.
*/
public static final Version DOWNGRADE_SAFE_VERSION = Version.V1;
/**
* Version that should be used for messaging serialization where mixed versions may be possible.
*
* As of this writing only 1 version exists, so this is the same as LATEST... Once v2 comes into the picture we need this version to be the oldest version needed for downgrade... If you upgrade from 5.1 to 5.2 (assuming this adds a v2) you need a version that works with 5.1 here.
*/
public static final Version CLUSTER_SAFE_VERSION = Version.V1;
/**
* Version number used in the serialization protocol. This is not the same as the messaging version, and is localized to this class.
*/
public final int version;
/**
* For the accord versioned serializers they sometimes need to access existing messaging serializers, in these cases an agreed messaging version is required and can not be plumbed directly from the messaging layer.
*
* @see #messageVersion()
*/
private final MessagingService.Version messagingVersion;
Version(int version, MessagingService.Version messagingVersion)
{
this.version = version;
this.messagingVersion = messagingVersion;
}
public static Version fromVersion(int version)
{
switch (version)
{
case 1: return V1;
default:
throw new IllegalArgumentException("Unknown version: " + version);
}
}
public static Version findBestMatchForMessagingVersion(int messagingVersion)
{
Version[] versions = values();
for (int i = versions.length - 1; i >= 0; i--)
{
Version v = versions[i];
// If network version bumped (12 to 13), the accord serializers may not have been changed; use the largest
// version smaller than or equal to this version
if (v.messageVersion() <= messagingVersion)
return v;
}
throw new IllegalArgumentException("Attempted to use message version " + messagingVersion + " which is smaller than " + versions[0] + " can handle (" + versions[0].messageVersion() + ")");
}
@Override
public int messageVersion()
{
return messagingVersion.value;
}
public List<Version> greaterThanOrEqual()
{
Version[] all = Version.values();
if (ordinal() == all.length - 1)
return Collections.singletonList(this);
List<Version> values = new ArrayList<>(all.length - ordinal());
for (int i = ordinal(); i < all.length; i++)
values.add(all[i]);
return values;
}
public enum Serializer implements UnversionedSerializer<Version>
{
instance;
@Override
public void serialize(Version t, DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(t.version);
}
@Override
public Version deserialize(DataInputPlus in) throws IOException
{
return Version.fromVersion(in.readUnsignedVInt32());
}
@Override
public long serializedSize(Version t)
{
return TypeSizes.sizeofUnsignedVInt(t.version);
}
}
}

2
src/java/org/apache/cassandra/service/accord/serializers/WaitingOnSerializer.java
View File

@ -86,7 +86,7 @@ public class WaitingOnSerializer
return result;
}
public void reserialize(DataOutputPlus out, int version) throws IOException
public void reserialize(DataOutputPlus out) throws IOException
{
out.writeUnsignedVInt32(waitingOnLength);
serialize(waitingOnLength, waitingOn, out);

79
src/java/org/apache/cassandra/service/accord/txn/AbstractSerialized.java
View File

@ -20,11 +20,15 @@ package org.apache.cassandra.service.accord.txn;
import java.nio.ByteBuffer;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.service.accord.AccordSerializers;
import accord.utils.Invariants;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.ByteBufferUtil;
import org.apache.cassandra.utils.ObjectSizes;
/**
* Item that is serialized by default
@ -32,25 +36,40 @@ import org.apache.cassandra.service.accord.AccordSerializers;
@NotThreadSafe
public abstract class AbstractSerialized<T>
{
private static final long EMPTY = ObjectSizes.measure(new AbstractSerialized<ByteBuffer>(null, null) {
@Override
protected IVersionedSerializer<ByteBuffer> serializer()
{
throw new AssertionError();
}
});
public final Version version;
private @Nullable final ByteBuffer bytes;
private @Nullable T memoized = null;
private transient @Nullable T memoized = null;
public AbstractSerialized(@Nullable ByteBuffer bytes)
public AbstractSerialized(@Nullable ByteBuffer bytes, Version version)
{
this.version = version;
this.bytes = bytes;
}
public AbstractSerialized(@Nullable T value)
public AbstractSerialized(T value)
{
this.bytes = value != null ? AccordSerializers.serialize(value, serializer()) : null;
this.version = Version.LATEST;
this.bytes = serializer().serializeUnchecked(Invariants.nonNull(value), version);
this.memoized = value;
}
public long estimatedSizeOnHeap()
{
return EMPTY + ByteBufferUtil.estimatedSizeOnHeap(bytes);
}
@Override
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (o == null || !(o instanceof AbstractSerialized)) return false;
AbstractSerialized<?> that = (AbstractSerialized<?>) o;
@ -66,16 +85,22 @@ public abstract class AbstractSerialized<T>
@Override
public String toString()
{
return get().toString();
return Objects.toString(get());
}
protected abstract IVersionedSerializer<T> serializer();
protected boolean isNull()
{
return bytes == null;
}
@Nullable
protected T get()
{
T result = memoized;
if (result == null && bytes != null)
memoized = result = AccordSerializers.deserialize(bytes, serializer());
memoized = result = serializer().deserializeUnchecked(bytes, version);
return result;
}
@ -84,8 +109,42 @@ public abstract class AbstractSerialized<T>
memoized = null;
}
protected ByteBuffer bytes()
@Nullable
protected ByteBuffer unsafeBytes()
{
return bytes;
}
@Nonnull
protected ByteBuffer bytes(Version target)
{
Invariants.nonNull(bytes);
if (version == target)
return bytes;
return serializer().serializeUnchecked(get(), target);
}
public static <T> AbstractSerialized<T> of(IVersionedSerializer<T> serializer, T value)
{
return new AbstractSerialized<T>(value)
{
@Override
protected IVersionedSerializer<T> serializer()
{
return serializer;
}
};
}
public static <T> AbstractSerialized<T> fromBytes(IVersionedSerializer<T> serializer, ByteBuffer bytes, Version version)
{
return new AbstractSerialized<T>(bytes, version)
{
@Override
protected IVersionedSerializer<T> serializer()
{
return serializer;
}
};
}
}

18
src/java/org/apache/cassandra/service/accord/txn/AccordUpdate.java
View File

@ -24,9 +24,10 @@ import javax.annotation.Nullable;
import accord.api.Data;
import accord.api.Update;
import org.apache.cassandra.db.ConsistencyLevel;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
public abstract class AccordUpdate implements Update
{
@ -78,9 +79,12 @@ public abstract class AccordUpdate implements Update
public interface AccordUpdateSerializer<T extends AccordUpdate> extends IVersionedSerializer<T>
{
void serialize(T update, DataOutputPlus out, int version) throws IOException;
T deserialize(DataInputPlus in, int version) throws IOException;
long serializedSize(T update, int version);
@Override
void serialize(T update, DataOutputPlus out, Version version) throws IOException;
@Override
T deserialize(DataInputPlus in, Version version) throws IOException;
@Override
long serializedSize(T update, Version version);
}
private static AccordUpdateSerializer serializerFor(AccordUpdate toSerialize)
@ -104,21 +108,21 @@ public abstract class AccordUpdate implements Update
public static final AccordUpdateSerializer<AccordUpdate> serializer = new AccordUpdateSerializer<AccordUpdate>()
{
@Override
public void serialize(AccordUpdate update, DataOutputPlus out, int version) throws IOException
public void serialize(AccordUpdate update, DataOutputPlus out, Version version) throws IOException
{
out.writeByte(update.kind().val);
serializerFor(update).serialize(update, out, version);
}
@Override
public AccordUpdate deserialize(DataInputPlus in, int version) throws IOException
public AccordUpdate deserialize(DataInputPlus in, Version version) throws IOException
{
Kind kind = Kind.valueOf(in.readByte());
return serializerFor(kind).deserialize(in, version);
}
@Override
public long serializedSize(AccordUpdate update, int version)
public long serializedSize(AccordUpdate update, Version version)
{
return 1 + serializerFor(update).serializedSize(update, version);
}

63
src/java/org/apache/cassandra/service/accord/txn/TxnCondition.java
View File

@ -43,10 +43,11 @@ import org.apache.cassandra.db.rows.Cell;
import org.apache.cassandra.db.rows.ColumnData;
import org.apache.cassandra.db.rows.ComplexColumnData;
import org.apache.cassandra.db.rows.Row;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.ColumnMetadata;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.transport.ProtocolVersion;
import org.apache.cassandra.utils.ByteBufferUtil;
@ -64,9 +65,9 @@ public abstract class TxnCondition
{
private interface ConditionSerializer<T extends TxnCondition>
{
void serialize(T condition, DataOutputPlus out, int version) throws IOException;
T deserialize(DataInputPlus in, int version, Kind kind) throws IOException;
long serializedSize(T condition, int version);
void serialize(T condition, DataOutputPlus out, Version version) throws IOException;
T deserialize(DataInputPlus in, Version version, Kind kind) throws IOException;
long serializedSize(T condition, Version version);
}
public enum Kind
@ -176,11 +177,11 @@ public abstract class TxnCondition
private static final ConditionSerializer<None> serializer = new ConditionSerializer<None>()
{
@Override
public void serialize(None condition, DataOutputPlus out, int version) {}
public void serialize(None condition, DataOutputPlus out, Version version) {}
@Override
public None deserialize(DataInputPlus in, int version, Kind kind) { return instance; }
public None deserialize(DataInputPlus in, Version version, Kind kind) { return instance; }
@Override
public long serializedSize(None condition, int version) { return 0; }
public long serializedSize(None condition, Version version) { return 0; }
};
}
@ -294,26 +295,27 @@ public abstract class TxnCondition
private static final ConditionSerializer<Exists> serializer = new ConditionSerializer<Exists>()
{
@Override
public void serialize(Exists condition, DataOutputPlus out, int version) throws IOException
public void serialize(Exists condition, DataOutputPlus out, Version version) throws IOException
{
TxnReference.serializer.serialize(condition.reference, out, version);
}
@Override
public Exists deserialize(DataInputPlus in, int version, Kind kind) throws IOException
public Exists deserialize(DataInputPlus in, Version version, Kind kind) throws IOException
{
return new Exists(TxnReference.serializer.deserialize(in, version), kind);
}
@Override
public long serializedSize(Exists condition, int version)
public long serializedSize(Exists condition, Version version)
{
return TxnReference.serializer.serializedSize(condition.reference, version);
}
};
}
public static class ColumnConditionsAdapter extends TxnCondition {
public static class ColumnConditionsAdapter extends TxnCondition
{
@Nonnull
public final Collection<Bound> bounds;
@ -346,25 +348,25 @@ public abstract class TxnCondition
private static final ConditionSerializer<ColumnConditionsAdapter> serializer = new ConditionSerializer<ColumnConditionsAdapter>()
{
@Override
public void serialize(ColumnConditionsAdapter condition, DataOutputPlus out, int version) throws IOException
public void serialize(ColumnConditionsAdapter condition, DataOutputPlus out, Version version) throws IOException
{
clusteringSerializer.serialize(condition.clustering, out, version);
serializeCollection(condition.bounds, out, version, Bound.serializer);
clusteringSerializer.serialize(condition.clustering, out);
serializeCollection(condition.bounds, out, Bound.serializer);
}
@Override
public ColumnConditionsAdapter deserialize(DataInputPlus in, int version, Kind ignored) throws IOException
public ColumnConditionsAdapter deserialize(DataInputPlus in, Version version, Kind ignored) throws IOException
{
Clustering<?> clustering = clusteringSerializer.deserialize(in, version);
List<Bound> bounds = deserializeList(in, version, Bound.serializer);
Clustering<?> clustering = clusteringSerializer.deserialize(in);
List<Bound> bounds = deserializeList(in, Bound.serializer);
return new ColumnConditionsAdapter(clustering, bounds);
}
@Override
public long serializedSize(ColumnConditionsAdapter condition, int version)
public long serializedSize(ColumnConditionsAdapter condition, Version version)
{
return clusteringSerializer.serializedSize(condition.clustering, version)
+ serializedCollectionSize(condition.bounds, version, Bound.serializer);
return clusteringSerializer.serializedSize(condition.clustering)
+ serializedCollectionSize(condition.bounds, Bound.serializer);
}
};
}
@ -458,7 +460,7 @@ public abstract class TxnCondition
private static final ConditionSerializer<Value> serializer = new ConditionSerializer<>()
{
@Override
public void serialize(Value condition, DataOutputPlus out, int version) throws IOException
public void serialize(Value condition, DataOutputPlus out, Version version) throws IOException
{
TxnReference.serializer.serialize(condition.reference, out, version);
ByteBufferUtil.writeWithVIntLength(condition.value, out);
@ -466,7 +468,7 @@ public abstract class TxnCondition
}
@Override
public Value deserialize(DataInputPlus in, int version, Kind kind) throws IOException
public Value deserialize(DataInputPlus in, Version version, Kind kind) throws IOException
{
TxnReference reference = TxnReference.serializer.deserialize(in, version);
ByteBuffer value = ByteBufferUtil.readWithVIntLength(in);
@ -475,7 +477,7 @@ public abstract class TxnCondition
}
@Override
public long serializedSize(Value condition, int version)
public long serializedSize(Value condition, Version version)
{
long size = 0;
size += TxnReference.serializer.serializedSize(condition.reference, version);
@ -538,19 +540,19 @@ public abstract class TxnCondition
private static final ConditionSerializer<BooleanGroup> serializer = new ConditionSerializer<BooleanGroup>()
{
@Override
public void serialize(BooleanGroup condition, DataOutputPlus out, int version) throws IOException
public void serialize(BooleanGroup condition, DataOutputPlus out, Version version) throws IOException
{
serializeList(condition.conditions, out, version, TxnCondition.serializer);
}
@Override
public BooleanGroup deserialize(DataInputPlus in, int version, Kind kind) throws IOException
public BooleanGroup deserialize(DataInputPlus in, Version version, Kind kind) throws IOException
{
return new BooleanGroup(kind, deserializeList(in, version, TxnCondition.serializer));
}
@Override
public long serializedSize(BooleanGroup condition, int version)
public long serializedSize(BooleanGroup condition, Version version)
{
return serializedListSize(condition.conditions, version, TxnCondition.serializer);
}
@ -561,14 +563,14 @@ public abstract class TxnCondition
{
@SuppressWarnings("unchecked")
@Override
public void serialize(TxnCondition condition, DataOutputPlus out, int version) throws IOException
public void serialize(TxnCondition condition, DataOutputPlus out, Version version) throws IOException
{
out.writeUnsignedVInt32(condition.kind.ordinal());
condition.kind.serializer().serialize(condition, out, version);
}
@Override
public TxnCondition deserialize(DataInputPlus in, int version) throws IOException
public TxnCondition deserialize(DataInputPlus in, Version version) throws IOException
{
Kind kind = Kind.values()[in.readUnsignedVInt32()];
return kind.serializer().deserialize(in, version, kind);
@ -576,9 +578,10 @@ public abstract class TxnCondition
@SuppressWarnings("unchecked")
@Override
public long serializedSize(TxnCondition condition, int version)
public long serializedSize(TxnCondition condition, Version version)
{
return TypeSizes.sizeofUnsignedVInt(condition.kind.ordinal()) + condition.kind.serializer().serializedSize(condition, version);
return TypeSizes.sizeofUnsignedVInt(condition.kind.ordinal())
+ condition.kind.serializer().serializedSize(condition, version);
}
};
}

19
src/java/org/apache/cassandra/service/accord/txn/TxnData.java
View File

@ -27,9 +27,11 @@ import org.apache.cassandra.db.EmptyIterators;
import org.apache.cassandra.db.SinglePartitionReadCommand;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.db.partitions.PartitionIterators;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.VersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.CollectionSerializers;
import org.apache.cassandra.utils.Int32Serializer;
import org.apache.cassandra.utils.NullableSerializer;
@ -170,26 +172,27 @@ public class TxnData extends Int2ObjectHashMap<TxnDataValue> implements TxnResul
return txn_data;
}
private static final IVersionedSerializer<Integer> INT32_SERIALIZER = IVersionedSerializer.fromSerializer(Int32Serializer.serializer);
public static final IVersionedSerializer<TxnData> serializer = new IVersionedSerializer<TxnData>()
{
@Override
public void serialize(TxnData data, DataOutputPlus out, int version) throws IOException
public void serialize(TxnData data, DataOutputPlus out, Version version) throws IOException
{
CollectionSerializers.serializeMap(data, out, version, Int32Serializer.serializer, TxnDataValue.serializer);
CollectionSerializers.serializeMap(data, out, version, INT32_SERIALIZER, TxnDataValue.serializer);
}
@Override
public TxnData deserialize(DataInputPlus in, int version) throws IOException
public TxnData deserialize(DataInputPlus in, Version version) throws IOException
{
return CollectionSerializers.deserializeMap(in, version, Int32Serializer.serializer, TxnDataValue.serializer, TxnData::newWithExpectedSize);
return CollectionSerializers.deserializeMap(in, version, INT32_SERIALIZER, TxnDataValue.serializer, TxnData::newWithExpectedSize);
}
@Override
public long serializedSize(TxnData data, int version)
public long serializedSize(TxnData data, Version version)
{
return CollectionSerializers.serializedMapSize(data, version, Int32Serializer.serializer, TxnDataValue.serializer);
return CollectionSerializers.serializedMapSize(data, version, INT32_SERIALIZER, TxnDataValue.serializer);
}
};
public static final IVersionedSerializer<TxnData> nullableSerializer = NullableSerializer.wrap(serializer);
public static final VersionedSerializer<TxnData, Version> nullableSerializer = NullableSerializer.wrap(serializer);
}

15
src/java/org/apache/cassandra/service/accord/txn/TxnDataKeyValue.java
View File

@ -32,6 +32,7 @@ import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.Schema;
import org.apache.cassandra.schema.TableId;
import org.apache.cassandra.schema.TableMetadata;
import org.apache.cassandra.service.accord.serializers.Version;
import static org.apache.cassandra.db.SerializationHeader.StableHeaderSerializer.STABLE;
import static org.apache.cassandra.db.rows.DeserializationHelper.Flag.FROM_REMOTE;
@ -72,34 +73,34 @@ public class TxnDataKeyValue extends FilteredPartition implements TxnDataValue
public static final TxnDataValueSerializer<TxnDataKeyValue> serializer = new TxnDataValueSerializer<>()
{
@Override
public void serialize(TxnDataKeyValue value, DataOutputPlus out, int version) throws IOException
public void serialize(TxnDataKeyValue value, DataOutputPlus out, Version version) throws IOException
{
value.metadata().id.serializeCompact(out);
try (UnfilteredRowIterator iterator = value.unfilteredIterator())
{
UnfilteredRowIteratorSerializer.serializer.serialize(iterator, out, version, value.rowCount(), STABLE, null);
UnfilteredRowIteratorSerializer.serializer.serialize(iterator, out, version.messageVersion(), value.rowCount(), STABLE, null);
}
}
@Override
public TxnDataKeyValue deserialize(DataInputPlus in, int version) throws IOException
public TxnDataKeyValue deserialize(DataInputPlus in, Version version) throws IOException
{
TableMetadata metadata = Schema.instance.getExistingTableMetadata(TableId.deserializeCompact(in));
UnfilteredRowIteratorSerializer.Header header = UnfilteredRowIteratorSerializer.serializer.deserializeHeader(metadata, in, version, FROM_REMOTE, STABLE, null);
try (UnfilteredRowIterator partition = UnfilteredRowIteratorSerializer.serializer.deserialize(in, version, metadata, FROM_REMOTE, header))
UnfilteredRowIteratorSerializer.Header header = UnfilteredRowIteratorSerializer.serializer.deserializeHeader(metadata, in, version.messageVersion(), FROM_REMOTE, STABLE, null);
try (UnfilteredRowIterator partition = UnfilteredRowIteratorSerializer.serializer.deserialize(in, version.messageVersion(), metadata, FROM_REMOTE, header))
{
return new TxnDataKeyValue(UnfilteredRowIterators.filter(partition, 0));
}
}
@Override
public long serializedSize(TxnDataKeyValue value, int version)
public long serializedSize(TxnDataKeyValue value, Version version)
{
TableId tableId = value.metadata().id;
long size = tableId.serializedCompactSize();
try (UnfilteredRowIterator iterator = value.unfilteredIterator())
{
return size + UnfilteredRowIteratorSerializer.serializer.serializedSize(iterator, version, value.rowCount(), STABLE, null);
return size + UnfilteredRowIteratorSerializer.serializer.serializedSize(iterator, version.messageVersion(), value.rowCount(), STABLE, null);
}
}
};

19
src/java/org/apache/cassandra/service/accord/txn/TxnDataRangeValue.java
View File

@ -40,6 +40,7 @@ import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.Schema;
import org.apache.cassandra.schema.TableId;
import org.apache.cassandra.schema.TableMetadata;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.ObjectSizes;
import static com.google.common.base.Preconditions.checkState;
@ -121,25 +122,25 @@ public class TxnDataRangeValue extends ArrayList<FilteredPartition> implements T
public static final TxnDataValueSerializer<TxnDataRangeValue> serializer = new TxnDataValueSerializer<>()
{
@Override
public void serialize(TxnDataRangeValue value, DataOutputPlus out, int version) throws IOException
public void serialize(TxnDataRangeValue value, DataOutputPlus out, Version version) throws IOException
{
out.writeUnsignedVInt32(value.size());
if (value.isEmpty())
return;
TableId.serializer.serialize(value.tableId(), out, version);
TableId.serializer.serialize(value.tableId(), out, version.messageVersion());
for (FilteredPartition partition : value)
{
try (UnfilteredRowIterator iterator = partition.unfilteredIterator())
{
UnfilteredRowIteratorSerializer.serializer.serialize(iterator, out, version, partition.rowCount(), STABLE, null);
UnfilteredRowIteratorSerializer.serializer.serialize(iterator, out, version.messageVersion(), partition.rowCount(), STABLE, null);
}
}
}
@Override
public TxnDataRangeValue deserialize(DataInputPlus in, int version) throws IOException
public TxnDataRangeValue deserialize(DataInputPlus in, Version version) throws IOException
{
int numPartitions = in.readUnsignedVInt32();
TxnDataRangeValue value = new TxnDataRangeValue(numPartitions);
@ -148,8 +149,8 @@ public class TxnDataRangeValue extends ArrayList<FilteredPartition> implements T
TableMetadata metadata = Schema.instance.getExistingTableMetadata(TableId.deserialize(in));
for (int i = 0; i < numPartitions; i++)
{
UnfilteredRowIteratorSerializer.Header header = UnfilteredRowIteratorSerializer.serializer.deserializeHeader(metadata, in, version, FROM_REMOTE, STABLE, null);
try (UnfilteredRowIterator partition = UnfilteredRowIteratorSerializer.serializer.deserialize(in, version, metadata, FROM_REMOTE, header))
UnfilteredRowIteratorSerializer.Header header = UnfilteredRowIteratorSerializer.serializer.deserializeHeader(metadata, in, version.messageVersion(), FROM_REMOTE, STABLE, null);
try (UnfilteredRowIterator partition = UnfilteredRowIteratorSerializer.serializer.deserialize(in, version.messageVersion(), metadata, FROM_REMOTE, header))
{
value.add(new FilteredPartition(UnfilteredRowIterators.filter(partition, 0)));
}
@ -158,17 +159,17 @@ public class TxnDataRangeValue extends ArrayList<FilteredPartition> implements T
}
@Override
public long serializedSize(TxnDataRangeValue value, int version)
public long serializedSize(TxnDataRangeValue value, Version version)
{
long size = TypeSizes.sizeofUnsignedVInt(value.size());
if (value.size() == 0)
return size;
size += TableId.serializer.serializedSize(value.tableId(), version);
size += TableId.serializer.serializedSize(value.tableId(), version.messageVersion());
for (FilteredPartition partition : value)
{
try (UnfilteredRowIterator iterator = partition.unfilteredIterator())
{
size += UnfilteredRowIteratorSerializer.serializer.serializedSize(iterator, version, partition.rowCount(), STABLE, null);
size += UnfilteredRowIteratorSerializer.serializer.serializedSize(iterator, version.messageVersion(), partition.rowCount(), STABLE, null);
}
}
return size;

12
src/java/org/apache/cassandra/service/accord/txn/TxnDataValue.java
View File

@ -20,9 +20,10 @@ package org.apache.cassandra.service.accord.txn;
import java.io.IOException;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import static org.apache.cassandra.db.TypeSizes.sizeof;
@ -31,7 +32,8 @@ import static org.apache.cassandra.db.TypeSizes.sizeof;
*/
public interface TxnDataValue
{
interface TxnDataValueSerializer<T extends TxnDataValue> extends IVersionedSerializer<T> {}
interface TxnDataValueSerializer<T extends TxnDataValue> extends IVersionedSerializer<T>
{}
enum Kind
{
@ -68,14 +70,14 @@ public interface TxnDataValue
{
@SuppressWarnings("unchecked")
@Override
public void serialize(TxnDataValue txnDataValue, DataOutputPlus out, int version) throws IOException
public void serialize(TxnDataValue txnDataValue, DataOutputPlus out, Version version) throws IOException
{
out.writeByte(txnDataValue.kind().ordinal());
txnDataValue.kind().serializer().serialize(txnDataValue, out, version);
}
@Override
public TxnDataValue deserialize(DataInputPlus in, int version) throws IOException
public TxnDataValue deserialize(DataInputPlus in, Version version) throws IOException
{
TxnDataValue.Kind kind = TxnDataValue.Kind.values()[in.readByte()];
return (TxnDataValue)kind.serializer().deserialize(in, version);
@ -83,7 +85,7 @@ public interface TxnDataValue
@SuppressWarnings("unchecked")
@Override
public long serializedSize(TxnDataValue txnDataValue, int version)
public long serializedSize(TxnDataValue txnDataValue, Version version)
{
return sizeof((byte)txnDataValue.kind().ordinal()) + txnDataValue.kind().serializer().serializedSize(txnDataValue, version);
}

71
src/java/org/apache/cassandra/service/accord/txn/TxnNamedRead.java
View File

@ -23,7 +23,6 @@ import java.nio.ByteBuffer;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import javax.annotation.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -54,7 +53,6 @@ import org.apache.cassandra.db.rows.RowIterator;
import org.apache.cassandra.dht.AbstractBounds;
import org.apache.cassandra.dht.Token;
import org.apache.cassandra.dht.Token.KeyBound;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.TableId;
@ -62,7 +60,9 @@ import org.apache.cassandra.service.accord.AccordObjectSizes;
import org.apache.cassandra.service.accord.TokenRange;
import org.apache.cassandra.service.accord.api.TokenKey;
import org.apache.cassandra.service.accord.api.PartitionKey;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.KeySerializers;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.service.accord.txn.TxnData.TxnDataNameKind;
import org.apache.cassandra.utils.ByteBufferUtil;
import org.apache.cassandra.utils.Comparables;
@ -79,18 +79,33 @@ public class TxnNamedRead extends AbstractSerialized<ReadCommand>
@SuppressWarnings("unused")
private static final Logger logger = LoggerFactory.getLogger(TxnNamedRead.class);
private static final long EMPTY_SIZE = ObjectSizes.measure(new TxnNamedRead(0, null, (ByteBuffer) null));
private static final long EMPTY_SIZE = ObjectSizes.measure(new TxnNamedRead(0, null, null, Version.LATEST));
private final int name;
private final Seekable key;
public TxnNamedRead(int name, @Nullable SinglePartitionReadCommand value)
public TxnNamedRead(int name, SinglePartitionReadCommand value)
{
super(value);
this.name = name;
this.key = new PartitionKey(value.metadata().id, value.partitionKey());
}
public TxnNamedRead(int name, AbstractBounds<PartitionPosition> range, PartitionRangeReadCommand value)
{
super(value);
TableId tableId = value.metadata().id;
this.name = name;
this.key = boundsAsAccordRange(range, tableId);
}
public TxnNamedRead(int name, Seekable key, ByteBuffer bytes, Version version)
{
super(bytes, version);
this.name = name;
this.key = key;
}
public static TokenRange boundsAsAccordRange(AbstractBounds<PartitionPosition> range, TableId tableId)
{
// Should already have been unwrapped
@ -127,33 +142,18 @@ public class TxnNamedRead extends AbstractSerialized<ReadCommand>
return TokenRange.create(startTokenKey, stopTokenKey);
}
public TxnNamedRead(int name, AbstractBounds<PartitionPosition> range, PartitionRangeReadCommand value)
{
super(value);
TableId tableId = value.metadata().id;
this.name = name;
this.key = boundsAsAccordRange(range, tableId);
}
public TxnNamedRead(int name, Seekable key, ByteBuffer bytes)
{
super(bytes);
this.name = name;
this.key = key;
}
public long estimatedSizeOnHeap()
{
long size = EMPTY_SIZE;
size += AccordObjectSizes.seekable(key);
size += (bytes() != null ? ByteBufferUtil.estimatedSizeOnHeap(bytes()) : 0);
size += (unsafeBytes() != null ? ByteBufferUtil.estimatedSizeOnHeap(unsafeBytes()) : 0);
return size;
}
@Override
protected IVersionedSerializer<ReadCommand> serializer()
{
return ReadCommand.serializer;
return readCommandSerializer;
}
@Override
@ -226,7 +226,7 @@ public class TxnNamedRead extends AbstractSerialized<ReadCommand>
return this;
Invariants.require(((Range)key).contains(range));
return new TxnNamedRead(txnDataName(), range, bytes());
return new TxnNamedRead(txnDataName(), range, unsafeBytes(), version);
}
public TxnNamedRead merge(TxnNamedRead with)
@ -241,7 +241,7 @@ public class TxnNamedRead extends AbstractSerialized<ReadCommand>
RoutingKey start = Comparables.min(thisRange.start(), thatRange.start());
RoutingKey end = Comparables.max(thisRange.end(), thatRange.end());
Range range = thisRange.newRange(start, end);
return new TxnNamedRead(txnDataName(), range, bytes());
return new TxnNamedRead(txnDataName(), range, unsafeBytes(), version);
}
public static boolean readsWithoutReconciliation(ConsistencyLevel consistencyLevel)
@ -433,15 +433,14 @@ public class TxnNamedRead extends AbstractSerialized<ReadCommand>
static final IVersionedSerializer<TxnNamedRead> serializer = new IVersionedSerializer<>()
{
@Override
public void serialize(TxnNamedRead read, DataOutputPlus out, int version) throws IOException
public void serialize(TxnNamedRead read, DataOutputPlus out, Version version) throws IOException
{
out.writeInt(read.name);
KeySerializers.seekable.serialize(read.key, out, version);
if (read.bytes() != null)
KeySerializers.seekable.serialize(read.key, out);
if (!read.isNull())
{
out.write(0);
writeWithVIntLength(read.bytes(), out);
writeWithVIntLength(read.bytes(version), out);
}
else
{
@ -450,24 +449,26 @@ public class TxnNamedRead extends AbstractSerialized<ReadCommand>
}
@Override
public TxnNamedRead deserialize(DataInputPlus in, int version) throws IOException
public TxnNamedRead deserialize(DataInputPlus in, Version version) throws IOException
{
int name = in.readInt();
Seekable key = KeySerializers.seekable.deserialize(in, version);
Seekable key = KeySerializers.seekable.deserialize(in);
ByteBuffer bytes = in.readByte() == 1 ? null : readWithVIntLength(in);
return new TxnNamedRead(name, key, bytes);
return new TxnNamedRead(name, key, bytes, version);
}
@Override
public long serializedSize(TxnNamedRead read, int version)
public long serializedSize(TxnNamedRead read, Version version)
{
long size = 0;
size += TypeSizes.sizeof(read.name);
size += KeySerializers.seekable.serializedSize(read.key, version);
size += KeySerializers.seekable.serializedSize(read.key);
size += TypeSizes.BYTE_SIZE; // is null
if (read.bytes() != null)
size += serializedSizeWithVIntLength(read.bytes());
if (!read.isNull())
size += serializedSizeWithVIntLength(read.bytes(version));
return size;
}
};
static final IVersionedSerializer<ReadCommand> readCommandSerializer = IVersionedSerializer.fromMessaging(ReadCommand.serializer);
}

10
src/java/org/apache/cassandra/service/accord/txn/TxnQuery.java
View File

@ -38,7 +38,7 @@ import org.apache.cassandra.db.PartitionRangeReadCommand;
import org.apache.cassandra.db.SinglePartitionReadCommand;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.db.partitions.PartitionIterator;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.metrics.ClientRequestsMetricsHolder;
@ -227,17 +227,17 @@ public abstract class TxnQuery implements Query
return SIZE;
}
public static final IVersionedSerializer<TxnQuery> serializer = new IVersionedSerializer<TxnQuery>()
public static final UnversionedSerializer<TxnQuery> serializer = new UnversionedSerializer<TxnQuery>()
{
@Override
public void serialize(TxnQuery query, DataOutputPlus out, int version) throws IOException
public void serialize(TxnQuery query, DataOutputPlus out) throws IOException
{
Preconditions.checkArgument(query == null | query == ALL | query == NONE | query == CONDITION | query == UNSAFE_EMPTY | query == RANGE_QUERY);
out.writeByte(query == null ? 0 : query.type());
}
@Override
public TxnQuery deserialize(DataInputPlus in, int version) throws IOException
public TxnQuery deserialize(DataInputPlus in) throws IOException
{
switch (in.readByte())
{
@ -252,7 +252,7 @@ public abstract class TxnQuery implements Query
}
@Override
public long serializedSize(TxnQuery query, int version)
public long serializedSize(TxnQuery query)
{
Preconditions.checkArgument(query == null | query == ALL | query == NONE | query == CONDITION | query == UNSAFE_EMPTY | query == RANGE_QUERY);
return TypeSizes.sizeof((byte)2);

17
src/java/org/apache/cassandra/service/accord/txn/TxnRead.java
View File

@ -49,10 +49,11 @@ import org.apache.cassandra.db.PartitionPosition;
import org.apache.cassandra.db.PartitionRangeReadCommand;
import org.apache.cassandra.db.SinglePartitionReadCommand;
import org.apache.cassandra.dht.AbstractBounds;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.api.PartitionKey;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.tcm.ClusterMetadata;
import org.apache.cassandra.utils.ObjectSizes;
@ -165,7 +166,7 @@ public class TxnRead extends AbstractKeySorted<TxnNamedRead> implements Read
{
List<TxnNamedRead> reads = new ArrayList<>(keys.size());
for (int i = 0; i < keys.size(); i++)
reads.add(new TxnNamedRead(txnDataName(USER, i), keys.get(i), null));
reads.add(new TxnNamedRead(txnDataName(USER, i), keys.get(i), null, Version.LATEST));
return new TxnRead(reads, null);
}
@ -393,13 +394,13 @@ public class TxnRead extends AbstractKeySorted<TxnNamedRead> implements Read
public static final IVersionedSerializer<TxnRead> serializer = new IVersionedSerializer<TxnRead>()
{
@Override
public void serialize(TxnRead read, DataOutputPlus out, int version) throws IOException
public void serialize(TxnRead read, DataOutputPlus out, Version version) throws IOException
{
if (read.items.length > 0)
{
out.write(TYPE_NOT_EMPTY);
serializeArray(read.items, out, version, TxnNamedRead.serializer);
serializeNullable(read.cassandraConsistencyLevel, out, version, consistencyLevelSerializer);
serializeNullable(read.cassandraConsistencyLevel, out, consistencyLevelSerializer);
}
else
{
@ -408,7 +409,7 @@ public class TxnRead extends AbstractKeySorted<TxnNamedRead> implements Read
}
@Override
public TxnRead deserialize(DataInputPlus in, int version) throws IOException
public TxnRead deserialize(DataInputPlus in, Version version) throws IOException
{
byte type = in.readByte();
switch (type)
@ -421,19 +422,19 @@ public class TxnRead extends AbstractKeySorted<TxnNamedRead> implements Read
return EMPTY_RANGE;
case TYPE_NOT_EMPTY:
TxnNamedRead[] items = deserializeArray(in, version, TxnNamedRead.serializer, TxnNamedRead[]::new);
ConsistencyLevel consistencyLevel = deserializeNullable(in, version, consistencyLevelSerializer);
ConsistencyLevel consistencyLevel = deserializeNullable(in, consistencyLevelSerializer);
return new TxnRead(items, consistencyLevel);
}
}
@Override
public long serializedSize(TxnRead read, int version)
public long serializedSize(TxnRead read, Version version)
{
long size = 1; // type
if (read.items.length > 0)
{
size += serializedArraySize(read.items, version, TxnNamedRead.serializer);
size += serializedNullableSize(read.cassandraConsistencyLevel, version, consistencyLevelSerializer);
size += serializedNullableSize(read.cassandraConsistencyLevel, consistencyLevelSerializer);
}
return size;
}

24
src/java/org/apache/cassandra/service/accord/txn/TxnReference.java
View File

@ -35,10 +35,11 @@ import org.apache.cassandra.db.rows.CellPath;
import org.apache.cassandra.db.rows.ColumnData;
import org.apache.cassandra.db.rows.ComplexColumnData;
import org.apache.cassandra.db.rows.Row;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.ColumnMetadata;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.ByteBufferUtil;
import static org.apache.cassandra.db.marshal.CollectionType.Kind.SET;
@ -46,18 +47,18 @@ import static org.apache.cassandra.service.accord.AccordSerializers.columnMetada
public class TxnReference
{
private final Integer tuple;
private final int tuple;
private final ColumnMetadata column;
private final CellPath path;
public TxnReference(Integer tuple, ColumnMetadata column, CellPath path)
public TxnReference(int tuple, ColumnMetadata column, CellPath path)
{
this.tuple = tuple;
this.column = column;
this.path = path;
}
public TxnReference(Integer tuple, ColumnMetadata column)
public TxnReference(int tuple, ColumnMetadata column)
{
this(tuple, column, null);
}
@ -68,7 +69,7 @@ public class TxnReference
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TxnReference reference = (TxnReference) o;
return tuple.equals(reference.tuple) && Objects.equals(column, reference.column) && Objects.equals(path, reference.path);
return tuple == reference.tuple && Objects.equals(column, reference.column) && Objects.equals(path, reference.path);
}
@Override
@ -290,34 +291,35 @@ public class TxnReference
static final IVersionedSerializer<TxnReference> serializer = new IVersionedSerializer<TxnReference>()
{
@Override
public void serialize(TxnReference reference, DataOutputPlus out, int version) throws IOException
public void serialize(TxnReference reference, DataOutputPlus out, Version version) throws IOException
{
out.writeInt(reference.tuple);
out.writeBoolean(reference.column != null);
if (reference.column != null)
columnMetadataSerializer.serialize(reference.column, out, version);
columnMetadataSerializer.serialize(reference.column, out);
out.writeBoolean(reference.path != null);
if (reference.path != null)
CollectionType.cellPathSerializer.serialize(reference.path, out);
}
@Override
public TxnReference deserialize(DataInputPlus in, int version) throws IOException
public TxnReference deserialize(DataInputPlus in, Version version) throws IOException
{
int name = in.readInt();
ColumnMetadata column = in.readBoolean() ? columnMetadataSerializer.deserialize(in, version) : null;
ColumnMetadata column = in.readBoolean() ? columnMetadataSerializer.deserialize(in) : null;
CellPath path = in.readBoolean() ? CollectionType.cellPathSerializer.deserialize(in) : null;
return new TxnReference(name, column, path);
}
@Override
public long serializedSize(TxnReference reference, int version)
public long serializedSize(TxnReference reference, Version version)
{
long size = 0;
size += TypeSizes.INT_SIZE;
size += TypeSizes.BOOL_SIZE;
if (reference.column != null)
size += columnMetadataSerializer.serializedSize(reference.column, version);
size += columnMetadataSerializer.serializedSize(reference.column);
size += TypeSizes.BOOL_SIZE;
if (reference.path != null)
size += CollectionType.cellPathSerializer.serializedSize(reference.path);
return size;

15
src/java/org/apache/cassandra/service/accord/txn/TxnReferenceOperation.java
View File

@ -43,11 +43,12 @@ import org.apache.cassandra.db.marshal.SetType;
import org.apache.cassandra.db.marshal.TupleType;
import org.apache.cassandra.db.marshal.UserType;
import org.apache.cassandra.db.rows.CellPath;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.ColumnMetadata;
import org.apache.cassandra.service.accord.AccordSerializers;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.ByteBufferUtil;
import static org.apache.cassandra.db.marshal.CollectionType.Kind.MAP;
@ -257,10 +258,10 @@ public class TxnReferenceOperation
static final IVersionedSerializer<TxnReferenceOperation> serializer = new IVersionedSerializer<TxnReferenceOperation>()
{
@Override
public void serialize(TxnReferenceOperation operation, DataOutputPlus out, int version) throws IOException
public void serialize(TxnReferenceOperation operation, DataOutputPlus out, Version version) throws IOException
{
out.writeByte(operation.kind.id);
columnMetadataSerializer.serialize(operation.receiver, out, version);
columnMetadataSerializer.serialize(operation.receiver, out);
TxnReferenceValue.serializer.serialize(operation.value, out, version);
out.writeBoolean(operation.key != null);
@ -273,10 +274,10 @@ public class TxnReferenceOperation
}
@Override
public TxnReferenceOperation deserialize(DataInputPlus in, int version) throws IOException
public TxnReferenceOperation deserialize(DataInputPlus in, Version version) throws IOException
{
Kind kind = Kind.from(in.readByte());
ColumnMetadata receiver = columnMetadataSerializer.deserialize(in, version);
ColumnMetadata receiver = columnMetadataSerializer.deserialize(in);
TxnReferenceValue value = TxnReferenceValue.serializer.deserialize(in, version);
ByteBuffer key = in.readBoolean() ? ByteBufferUtil.readWithVIntLength(in) : null;
ByteBuffer field = in.readBoolean() ? ByteBufferUtil.readWithVIntLength(in) : null;
@ -284,10 +285,10 @@ public class TxnReferenceOperation
}
@Override
public long serializedSize(TxnReferenceOperation operation, int version)
public long serializedSize(TxnReferenceOperation operation, Version version)
{
long size = Byte.BYTES;
size += columnMetadataSerializer.serializedSize(operation.receiver, version);
size += columnMetadataSerializer.serializedSize(operation.receiver);
size += TxnReferenceValue.serializer.serializedSize(operation.value, version);
if (operation.key != null)

15
src/java/org/apache/cassandra/service/accord/txn/TxnReferenceOperations.java
View File

@ -27,10 +27,11 @@ import com.google.common.base.Preconditions;
import org.apache.cassandra.db.Clustering;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.TableMetadata;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import static org.apache.cassandra.utils.CollectionSerializers.deserializeList;
import static org.apache.cassandra.utils.CollectionSerializers.serializeList;
@ -89,7 +90,7 @@ public class TxnReferenceOperations
static final IVersionedSerializer<TxnReferenceOperations> serializer = new IVersionedSerializer<TxnReferenceOperations>()
{
@Override
public void serialize(TxnReferenceOperations operations, DataOutputPlus out, int version) throws IOException
public void serialize(TxnReferenceOperations operations, DataOutputPlus out, Version version) throws IOException
{
out.writeBoolean(!operations.isEmpty());
if (operations.isEmpty())
@ -97,25 +98,25 @@ public class TxnReferenceOperations
tableMetadataSerializer.serialize(operations.metadata, out, version);
out.writeBoolean(operations.clustering != null);
if (operations.clustering != null)
Clustering.serializer.serialize(operations.clustering, out, version, operations.metadata.comparator.subtypes());
Clustering.serializer.serialize(operations.clustering, out, version.messageVersion(), operations.metadata.comparator.subtypes());
serializeList(operations.regulars, out, version, TxnReferenceOperation.serializer);
serializeList(operations.statics, out, version, TxnReferenceOperation.serializer);
}
@Override
public TxnReferenceOperations deserialize(DataInputPlus in, int version) throws IOException
public TxnReferenceOperations deserialize(DataInputPlus in, Version version) throws IOException
{
if (!in.readBoolean())
return TxnReferenceOperations.empty();
TableMetadata metadata = tableMetadataSerializer.deserialize(in, version);
Clustering<?> clustering = in.readBoolean() ? Clustering.serializer.deserialize(in, version, metadata.comparator.subtypes()) : null;
Clustering<?> clustering = in.readBoolean() ? Clustering.serializer.deserialize(in, version.messageVersion(), metadata.comparator.subtypes()) : null;
return new TxnReferenceOperations(metadata, clustering, deserializeList(in, version, TxnReferenceOperation.serializer),
deserializeList(in, version, TxnReferenceOperation.serializer));
}
@Override
public long serializedSize(TxnReferenceOperations operations, int version)
public long serializedSize(TxnReferenceOperations operations, Version version)
{
long size = TypeSizes.BOOL_SIZE;
if (operations.isEmpty())
@ -123,7 +124,7 @@ public class TxnReferenceOperations
size += tableMetadataSerializer.serializedSize(operations.metadata, version);
size += TypeSizes.BOOL_SIZE;
if (operations.clustering != null)
size += Clustering.serializer.serializedSize(operations.clustering, version, operations.metadata.comparator.subtypes());
size += Clustering.serializer.serializedSize(operations.clustering, version.messageVersion(), operations.metadata.comparator.subtypes());
size += serializedListSize(operations.regulars, version, TxnReferenceOperation.serializer);
size += serializedListSize(operations.statics, version, TxnReferenceOperation.serializer);
return size;

27
src/java/org/apache/cassandra/service/accord/txn/TxnReferenceValue.java
View File

@ -24,18 +24,19 @@ import java.util.Objects;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.db.marshal.AbstractType;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.ByteBufferUtil;
public abstract class TxnReferenceValue
{
private interface Serializer<T extends TxnReferenceValue>
{
void serialize(T t, DataOutputPlus out, int version) throws IOException;
T deserialize(DataInputPlus in, int version, Kind kind) throws IOException;
long serializedSize(T t, int version);
void serialize(T t, DataOutputPlus out, Version version) throws IOException;
T deserialize(DataInputPlus in, Version version, Kind kind) throws IOException;
long serializedSize(T t, Version version);
}
enum Kind
@ -105,19 +106,19 @@ public abstract class TxnReferenceValue
private static final Serializer<Constant> serializer = new Serializer<Constant>()
{
@Override
public void serialize(Constant constant, DataOutputPlus out, int version) throws IOException
public void serialize(Constant constant, DataOutputPlus out, Version version) throws IOException
{
ByteBufferUtil.writeWithVIntLength(constant.value, out);
}
@Override
public Constant deserialize(DataInputPlus in, int version, Kind kind) throws IOException
public Constant deserialize(DataInputPlus in, Version version, Kind kind) throws IOException
{
return new Constant(ByteBufferUtil.readWithVIntLength(in));
}
@Override
public long serializedSize(Constant constant, int version)
public long serializedSize(Constant constant, Version version)
{
return ByteBufferUtil.serializedSizeWithVIntLength(constant.value);
}
@ -169,19 +170,19 @@ public abstract class TxnReferenceValue
private static final Serializer<Substitution> serializer = new Serializer<Substitution>()
{
@Override
public void serialize(Substitution substitution, DataOutputPlus out, int version) throws IOException
public void serialize(Substitution substitution, DataOutputPlus out, Version version) throws IOException
{
TxnReference.serializer.serialize(substitution.reference, out, version);
}
@Override
public Substitution deserialize(DataInputPlus in, int version, Kind kind) throws IOException
public Substitution deserialize(DataInputPlus in, Version version, Kind kind) throws IOException
{
return new Substitution(TxnReference.serializer.deserialize(in, version));
}
@Override
public long serializedSize(Substitution substitution, int version)
public long serializedSize(Substitution substitution, Version version)
{
return TxnReference.serializer.serializedSize(substitution.reference, version);
}
@ -192,14 +193,14 @@ public abstract class TxnReferenceValue
{
@SuppressWarnings("unchecked")
@Override
public void serialize(TxnReferenceValue value, DataOutputPlus out, int version) throws IOException
public void serialize(TxnReferenceValue value, DataOutputPlus out, Version version) throws IOException
{
out.writeUnsignedVInt32(value.kind().ordinal());
value.kind().serializer.serialize(value, out, version);
}
@Override
public TxnReferenceValue deserialize(DataInputPlus in, int version) throws IOException
public TxnReferenceValue deserialize(DataInputPlus in, Version version) throws IOException
{
Kind kind = Kind.values()[in.readUnsignedVInt32()];
return kind.serializer.deserialize(in, version, kind);
@ -207,7 +208,7 @@ public abstract class TxnReferenceValue
@SuppressWarnings("unchecked")
@Override
public long serializedSize(TxnReferenceValue value, int version)
public long serializedSize(TxnReferenceValue value, Version version)
{
return TypeSizes.sizeofUnsignedVInt(value.kind().ordinal()) + value.kind().serializer.serializedSize(value, version);
}

66
src/java/org/apache/cassandra/service/accord/txn/TxnUpdate.java
View File

@ -39,16 +39,15 @@ import accord.primitives.Timestamp;
import org.apache.cassandra.cql3.QueryOptions;
import org.apache.cassandra.db.ConsistencyLevel;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputBuffer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.net.MessagingService;
import org.apache.cassandra.service.accord.AccordObjectSizes;
import org.apache.cassandra.service.accord.AccordSerializers;
import org.apache.cassandra.service.accord.IAccordService;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.KeySerializers;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.tcm.ClusterMetadata;
import org.apache.cassandra.transport.ProtocolVersion;
import org.apache.cassandra.utils.ByteBufferUtil;
@ -58,7 +57,6 @@ import static accord.utils.Invariants.requireArgument;
import static accord.utils.SortedArrays.Search.CEIL;
import static com.google.common.base.Preconditions.checkState;
import static org.apache.cassandra.service.accord.AccordSerializers.consistencyLevelSerializer;
import static org.apache.cassandra.service.accord.AccordSerializers.serialize;
import static org.apache.cassandra.utils.ArraySerializers.deserializeArray;
import static org.apache.cassandra.utils.ArraySerializers.serializeArray;
import static org.apache.cassandra.utils.ArraySerializers.serializedArraySize;
@ -76,7 +74,7 @@ public class TxnUpdate extends AccordUpdate
private final Keys keys;
private final ByteBuffer[] fragments;
private final ByteBuffer condition;
private final AbstractSerialized<TxnCondition> condition;
@Nullable
private final ConsistencyLevel cassandraCommitCL;
@ -95,13 +93,16 @@ public class TxnUpdate extends AccordUpdate
// TODO: Figure out a way to shove keys into TxnCondition, and have it implement slice/merge.
this.keys = Keys.of(fragments, fragment -> fragment.key);
fragments.sort(TxnWrite.Fragment::compareKeys);
this.fragments = toSerializedValuesArray(keys, fragments, fragment -> fragment.key, TxnWrite.Fragment.serializer);
this.condition = serialize(condition, TxnCondition.serializer);
//TODO (correctness): this node could be on version N while the peers are on N-1, which would have issues as the peers wouldn't know about N yet.
// Can not eagerly serialize until we know the "correct" version, else we need a way to fallback on mismatch.
this.fragments = toSerializedValuesArray(keys, fragments, fragment -> fragment.key, Version.LATEST, TxnWrite.Fragment.serializer);
this.condition = AbstractSerialized.of(TxnCondition.serializer, condition);
this.condition.unmemoize();
this.cassandraCommitCL = cassandraCommitCL;
this.preserveTimestamps = preserveTimestamps;
}
private TxnUpdate(Keys keys, ByteBuffer[] fragments, ByteBuffer condition, ConsistencyLevel cassandraCommitCL, boolean preserveTimestamps)
private TxnUpdate(Keys keys, ByteBuffer[] fragments, AbstractSerialized<TxnCondition> condition, ConsistencyLevel cassandraCommitCL, boolean preserveTimestamps)
{
this.keys = keys;
this.fragments = fragments;
@ -118,7 +119,7 @@ public class TxnUpdate extends AccordUpdate
@Override
public long estimatedSizeOnHeap()
{
long size = EMPTY_SIZE + ByteBufferUtil.estimatedSizeOnHeap(condition);
long size = EMPTY_SIZE + condition.estimatedSizeOnHeap();
for (ByteBuffer update : fragments)
size += ByteBufferUtil.estimatedSizeOnHeap(update);
size += AccordObjectSizes.keys(keys);
@ -129,7 +130,7 @@ public class TxnUpdate extends AccordUpdate
public String toString()
{
return "TxnUpdate{updates=" + deserialize(fragments, TxnWrite.Fragment.serializer) +
", condition=" + AccordSerializers.deserialize(condition, TxnCondition.serializer) + '}';
", condition=" + condition.get() + '}';
}
@Override
@ -257,41 +258,40 @@ public class TxnUpdate extends AccordUpdate
public static final AccordUpdateSerializer<TxnUpdate> serializer = new AccordUpdateSerializer<TxnUpdate>()
{
@Override
public void serialize(TxnUpdate update, DataOutputPlus out, int version) throws IOException
public void serialize(TxnUpdate update, DataOutputPlus out, Version version) throws IOException
{
out.writeByte(update.preserveTimestamps ? FLAG_PRESERVE_TIMESTAMPS : 0);
KeySerializers.keys.serialize(update.keys, out, version);
writeWithVIntLength(update.condition, out);
serializeArray(update.fragments, out, version, ByteBufferUtil.byteBufferSerializer);
serializeNullable(update.cassandraCommitCL, out, version, consistencyLevelSerializer);
KeySerializers.keys.serialize(update.keys, out);
writeWithVIntLength(update.condition.bytes(version), out);
serializeArray(update.fragments, out, ByteBufferUtil.byteBufferSerializer);
serializeNullable(update.cassandraCommitCL, out, consistencyLevelSerializer);
}
@Override
public TxnUpdate deserialize(DataInputPlus in, int version) throws IOException
public TxnUpdate deserialize(DataInputPlus in, Version version) throws IOException
{
int flags = in.readByte();
boolean preserveTimestamps = (FLAG_PRESERVE_TIMESTAMPS & flags) == 1;
Keys keys = KeySerializers.keys.deserialize(in, version);
Keys keys = KeySerializers.keys.deserialize(in);
ByteBuffer condition = readWithVIntLength(in);
ByteBuffer[] fragments = deserializeArray(in, version, ByteBufferUtil.byteBufferSerializer, ByteBuffer[]::new);
ConsistencyLevel consistencyLevel = deserializeNullable(in, version, consistencyLevelSerializer);
return new TxnUpdate(keys, fragments, condition, consistencyLevel, preserveTimestamps);
ByteBuffer[] fragments = deserializeArray(in, ByteBufferUtil.byteBufferSerializer, ByteBuffer[]::new);
ConsistencyLevel consistencyLevel = deserializeNullable(in, consistencyLevelSerializer);
return new TxnUpdate(keys, fragments, AbstractSerialized.fromBytes(TxnCondition.serializer, condition, version), consistencyLevel, preserveTimestamps);
}
@Override
public long serializedSize(TxnUpdate update, int version)
public long serializedSize(TxnUpdate update, Version version)
{
long size = 1; // flags
size += KeySerializers.keys.serializedSize(update.keys, version);
size += serializedSizeWithVIntLength(update.condition);
size += serializedArraySize(update.fragments, version, ByteBufferUtil.byteBufferSerializer);
size += serializedNullableSize(update.cassandraCommitCL, version, consistencyLevelSerializer);
assert(ByteBufferUtil.serialized(this, update, version).remaining() == size);
size += KeySerializers.keys.serializedSize(update.keys);
size += serializedSizeWithVIntLength(update.condition.bytes(version));
size += serializedArraySize(update.fragments, ByteBufferUtil.byteBufferSerializer);
size += serializedNullableSize(update.cassandraCommitCL, consistencyLevelSerializer);
return size;
}
};
private static <T> ByteBuffer[] toSerializedValuesArray(Keys keys, List<T> items, Function<? super T, ? extends Key> toKey, IVersionedSerializer<T> serializer)
private static <T> ByteBuffer[] toSerializedValuesArray(Keys keys, List<T> items, Function<? super T, ? extends Key> toKey, Version version, IVersionedSerializer<T> serializer)
{
ByteBuffer[] result = new ByteBuffer[keys.size()];
int i = 0, mi = items.size(), ki = 0;
@ -305,22 +305,22 @@ public class TxnUpdate extends AccordUpdate
int nextki = keys.findNext(ki, key, CEIL);
Arrays.fill(result, ki, nextki, ByteBufferUtil.EMPTY_BYTE_BUFFER);
ki = nextki;
result[ki++] = toSerializedValues(items, i, j, serializer, MessagingService.current_version);
result[ki++] = toSerializedValues(items, i, j, serializer, version);
i = j;
}
Arrays.fill(result, ki, result.length, ByteBufferUtil.EMPTY_BYTE_BUFFER);
return result;
}
private static <T> ByteBuffer toSerializedValues(List<T> items, int start, int end, IVersionedSerializer<T> serializer, int version)
private static <T> ByteBuffer toSerializedValues(List<T> items, int start, int end, IVersionedSerializer<T> serializer, Version version)
{
long size = TypeSizes.sizeofUnsignedVInt(version) + TypeSizes.sizeofUnsignedVInt(end - start);
long size = TypeSizes.sizeofUnsignedVInt(version.version) + TypeSizes.sizeofUnsignedVInt(end - start);
for (int i = start ; i < end ; ++i)
size += serializer.serializedSize(items.get(i), version);
try (DataOutputBuffer out = new DataOutputBuffer((int) size))
{
out.writeUnsignedVInt32(version);
out.writeUnsignedVInt32(version.version);
out.writeUnsignedVInt32(end - start);
for (int i = start ; i < end ; ++i)
serializer.serialize(items.get(i), out, version);
@ -339,7 +339,7 @@ public class TxnUpdate extends AccordUpdate
try (DataInputBuffer in = new DataInputBuffer(bytes, true))
{
int version = in.readUnsignedVInt32();
Version version = Version.fromVersion(in.readUnsignedVInt32());
int count = in.readUnsignedVInt32();
switch (count)
{
@ -372,7 +372,7 @@ public class TxnUpdate extends AccordUpdate
// Assert data that was memoized is same as data that is provided?
if (conditionResult != null)
return conditionResult;
TxnCondition condition = AccordSerializers.deserialize(this.condition, TxnCondition.serializer);
TxnCondition condition = this.condition.get();
if (condition == TxnCondition.none())
return conditionResult = true;
return conditionResult = condition.applies((TxnData) data);

56
src/java/org/apache/cassandra/service/accord/txn/TxnWrite.java
View File

@ -54,12 +54,13 @@ import org.apache.cassandra.db.RegularAndStaticColumns;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.db.partitions.PartitionUpdate;
import org.apache.cassandra.db.rows.Row;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.schema.ColumnMetadata;
import org.apache.cassandra.service.accord.AccordObjectSizes;
import org.apache.cassandra.service.accord.api.PartitionKey;
import org.apache.cassandra.service.accord.serializers.IVersionedSerializer;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.utils.BooleanSerializer;
import org.apache.cassandra.utils.ByteBufferUtil;
import org.apache.cassandra.utils.ObjectSizes;
@ -81,7 +82,7 @@ public class TxnWrite extends AbstractKeySorted<TxnWrite.Update> implements Writ
public static class Update extends AbstractSerialized<PartitionUpdate>
{
private static final long EMPTY_SIZE = ObjectSizes.measure(new Update(null, 0, (ByteBuffer) null));
private static final long EMPTY_SIZE = ObjectSizes.measure(new Update(null, 0, ByteBufferUtil.EMPTY_BYTE_BUFFER, Version.LATEST));
public final PartitionKey key;
public final int index;
@ -92,18 +93,19 @@ public class TxnWrite extends AbstractKeySorted<TxnWrite.Update> implements Writ
this.index = index;
}
private Update(PartitionKey key, int index, ByteBuffer bytes)
private Update(PartitionKey key, int index, ByteBuffer bytes, Version version)
{
super(bytes);
super(bytes, version);
this.key = key;
this.index = index;
}
long estimatedSizeOnHeap()
@Override
public long estimatedSizeOnHeap()
{
return EMPTY_SIZE
+ AccordObjectSizes.key(key)
+ ByteBufferUtil.estimatedSizeOnHeap(bytes());
+ ByteBufferUtil.estimatedSizeOnHeap(unsafeBytes());
}
@Override
@ -150,29 +152,29 @@ public class TxnWrite extends AbstractKeySorted<TxnWrite.Update> implements Writ
public static final IVersionedSerializer<Update> serializer = new IVersionedSerializer<Update>()
{
@Override
public void serialize(Update write, DataOutputPlus out, int version) throws IOException
public void serialize(Update write, DataOutputPlus out, Version version) throws IOException
{
PartitionKey.serializer.serialize(write.key, out, version);
PartitionKey.serializer.serialize(write.key, out);
out.writeInt(write.index);
ByteBufferUtil.writeWithVIntLength(write.bytes(), out);
ByteBufferUtil.writeWithVIntLength(write.bytes(version), out);
}
@Override
public Update deserialize(DataInputPlus in, int version) throws IOException
public Update deserialize(DataInputPlus in, Version version) throws IOException
{
PartitionKey key = PartitionKey.serializer.deserialize(in, version);
PartitionKey key = PartitionKey.serializer.deserialize(in);
int index = in.readInt();
ByteBuffer bytes = ByteBufferUtil.readWithVIntLength(in);
return new Update(key, index, bytes);
return new Update(key, index, bytes, version);
}
@Override
public long serializedSize(Update write, int version)
public long serializedSize(Update write, Version version)
{
long size = 0;
size += PartitionKey.serializer.serializedSize(write.key, version);
size += PartitionKey.serializer.serializedSize(write.key);
size += TypeSizes.INT_SIZE;
size += ByteBufferUtil.serializedSizeWithVIntLength(write.bytes());
size += ByteBufferUtil.serializedSizeWithVIntLength(write.bytes(version));
return size;
}
};
@ -302,18 +304,18 @@ public class TxnWrite extends AbstractKeySorted<TxnWrite.Update> implements Writ
static final IVersionedSerializer<Fragment> serializer = new IVersionedSerializer<>()
{
@Override
public void serialize(Fragment fragment, DataOutputPlus out, int version) throws IOException
public void serialize(Fragment fragment, DataOutputPlus out, Version version) throws IOException
{
PartitionKey.serializer.serialize(fragment.key, out, version);
PartitionKey.serializer.serialize(fragment.key, out);
out.writeUnsignedVInt32(fragment.index);
partitionUpdateSerializer.serialize(fragment.baseUpdate, out, version);
TxnReferenceOperations.serializer.serialize(fragment.referenceOps, out, version);
}
@Override
public Fragment deserialize(DataInputPlus in, int version) throws IOException
public Fragment deserialize(DataInputPlus in, Version version) throws IOException
{
PartitionKey key = PartitionKey.serializer.deserialize(in, version);
PartitionKey key = PartitionKey.serializer.deserialize(in);
int idx = in.readUnsignedVInt32();
PartitionUpdate baseUpdate = partitionUpdateSerializer.deserialize(in, version);
TxnReferenceOperations referenceOps = TxnReferenceOperations.serializer.deserialize(in, version);
@ -321,10 +323,10 @@ public class TxnWrite extends AbstractKeySorted<TxnWrite.Update> implements Writ
}
@Override
public long serializedSize(Fragment fragment, int version)
public long serializedSize(Fragment fragment, Version version)
{
long size = 0;
size += PartitionKey.serializer.serializedSize(fragment.key, version);
size += PartitionKey.serializer.serializedSize(fragment.key);
size += TypeSizes.sizeofUnsignedVInt(fragment.index);
size += partitionUpdateSerializer.serializedSize(fragment.baseUpdate, version);
size += TxnReferenceOperations.serializer.serializedSize(fragment.referenceOps, version);
@ -423,23 +425,23 @@ public class TxnWrite extends AbstractKeySorted<TxnWrite.Update> implements Writ
public static final IVersionedSerializer<TxnWrite> serializer = new IVersionedSerializer<TxnWrite>()
{
@Override
public void serialize(TxnWrite write, DataOutputPlus out, int version) throws IOException
public void serialize(TxnWrite write, DataOutputPlus out, Version version) throws IOException
{
BooleanSerializer.serializer.serialize(write.isConditionMet, out, version);
BooleanSerializer.serializer.serialize(write.isConditionMet, out);
serializeArray(write.items, out, version, Update.serializer);
}
@Override
public TxnWrite deserialize(DataInputPlus in, int version) throws IOException
public TxnWrite deserialize(DataInputPlus in, Version version) throws IOException
{
boolean isConditionMet = BooleanSerializer.serializer.deserialize(in, version);
boolean isConditionMet = BooleanSerializer.serializer.deserialize(in);
return new TxnWrite(deserializeArray(in, version, Update.serializer, Update[]::new), isConditionMet);
}
@Override
public long serializedSize(TxnWrite write, int version)
public long serializedSize(TxnWrite write, Version version)
{
return BooleanSerializer.serializer.serializedSize(write.isConditionMet, version) + serializedArraySize(write.items, version, Update.serializer);
return BooleanSerializer.serializer.serializedSize(write.isConditionMet) + serializedArraySize(write.items, version, Update.serializer);
}
};
}

7
src/java/org/apache/cassandra/service/accord/txn/UnrecoverableRepairUpdate.java
View File

@ -40,6 +40,7 @@ import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.locator.Endpoints;
import org.apache.cassandra.locator.Replica;
import org.apache.cassandra.locator.ReplicaPlan;
import org.apache.cassandra.service.accord.serializers.Version;
import org.apache.cassandra.service.reads.ReadCoordinator;
import org.apache.cassandra.service.reads.repair.BlockingReadRepair;
@ -181,18 +182,18 @@ public class UnrecoverableRepairUpdate<E extends Endpoints<E>, P extends Replica
public static final AccordUpdateSerializer<UnrecoverableRepairUpdate> serializer = new AccordUpdateSerializer<>()
{
@Override
public void serialize(UnrecoverableRepairUpdate update, DataOutputPlus out, int version)
public void serialize(UnrecoverableRepairUpdate update, DataOutputPlus out, Version version)
{
}
@Override
public UnrecoverableRepairUpdate deserialize(DataInputPlus in, int version)
public UnrecoverableRepairUpdate deserialize(DataInputPlus in, Version version)
{
return null;
}
@Override
public long serializedSize(UnrecoverableRepairUpdate update, int version)
public long serializedSize(UnrecoverableRepairUpdate update, Version version)
{
return 0;
}

22
src/java/org/apache/cassandra/service/consensus/migration/ConsensusKeyMigrationState.java
View File

@ -48,7 +48,7 @@ import org.apache.cassandra.db.SystemKeyspace;
import org.apache.cassandra.db.WriteType;
import org.apache.cassandra.exceptions.CasWriteTimeoutException;
import org.apache.cassandra.exceptions.RetryOnDifferentSystemException;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.locator.EndpointsForToken;
@ -118,31 +118,31 @@ public abstract class ConsensusKeyMigrationState
this.consensusMigratedAt = consensusMigratedAt;
}
public static final IVersionedSerializer<ConsensusKeyMigrationFinished> serializer = new IVersionedSerializer<ConsensusKeyMigrationFinished>()
public static final UnversionedSerializer<ConsensusKeyMigrationFinished> serializer = new UnversionedSerializer<ConsensusKeyMigrationFinished>()
{
@Override
public void serialize(ConsensusKeyMigrationFinished t, DataOutputPlus out, int version) throws IOException
public void serialize(ConsensusKeyMigrationFinished t, DataOutputPlus out) throws IOException
{
UUIDSerializer.serializer.serialize(t.tableId, out, version);
UUIDSerializer.serializer.serialize(t.tableId, out);
ByteBufferUtil.writeWithVIntLength(t.partitionKey, out);
ConsensusMigratedAt.serializer.serialize(t.consensusMigratedAt, out, version);
ConsensusMigratedAt.serializer.serialize(t.consensusMigratedAt, out);
}
@Override
public ConsensusKeyMigrationFinished deserialize(DataInputPlus in, int version) throws IOException
public ConsensusKeyMigrationFinished deserialize(DataInputPlus in) throws IOException
{
UUID tableId = UUIDSerializer.serializer.deserialize(in, version);
UUID tableId = UUIDSerializer.serializer.deserialize(in);
ByteBuffer partitionKey = ByteBufferUtil.readWithVIntLength(in);
ConsensusMigratedAt consensusMigratedAt = ConsensusMigratedAt.serializer.deserialize(in, version);
ConsensusMigratedAt consensusMigratedAt = ConsensusMigratedAt.serializer.deserialize(in);
return new ConsensusKeyMigrationFinished(tableId, partitionKey, consensusMigratedAt);
}
@Override
public long serializedSize(ConsensusKeyMigrationFinished t, int version)
public long serializedSize(ConsensusKeyMigrationFinished t)
{
return UUIDSerializer.serializer.serializedSize(t.tableId, version)
return UUIDSerializer.serializer.serializedSize(t.tableId)
+ ByteBufferUtil.serializedSizeWithVIntLength(t.partitionKey)
+ ConsensusMigratedAt.serializer.serializedSize(t.consensusMigratedAt, version);
+ ConsensusMigratedAt.serializer.serializedSize(t.consensusMigratedAt);
}
};
}

16
src/java/org/apache/cassandra/service/consensus/migration/ConsensusMigratedAt.java
View File

@ -22,7 +22,7 @@ import java.io.IOException;
import javax.annotation.Nullable;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.tcm.Epoch;
@ -30,28 +30,28 @@ import org.apache.cassandra.utils.NullableSerializer;
public class ConsensusMigratedAt
{
public static final IVersionedSerializer<ConsensusMigratedAt> serializer = NullableSerializer.wrap(new IVersionedSerializer<ConsensusMigratedAt>()
public static final UnversionedSerializer<ConsensusMigratedAt> serializer = NullableSerializer.wrap(new UnversionedSerializer<ConsensusMigratedAt>()
{
@Override
public void serialize(ConsensusMigratedAt t, DataOutputPlus out, int version) throws IOException
public void serialize(ConsensusMigratedAt t, DataOutputPlus out) throws IOException
{
Epoch.messageSerializer.serialize(t.migratedAtEpoch, out, version);
Epoch.serializer.serialize(t.migratedAtEpoch, out);
out.writeByte(t.migratedAtTarget.value);
}
@Override
public ConsensusMigratedAt deserialize(DataInputPlus in, int version) throws IOException
public ConsensusMigratedAt deserialize(DataInputPlus in) throws IOException
{
Epoch migratedAtEpoch = Epoch.messageSerializer.deserialize(in, version);
Epoch migratedAtEpoch = Epoch.serializer.deserialize(in);
ConsensusMigrationTarget target = ConsensusMigrationTarget.fromValue(in.readByte());
return new ConsensusMigratedAt(migratedAtEpoch, target);
}
@Override
public long serializedSize(ConsensusMigratedAt t, int version)
public long serializedSize(ConsensusMigratedAt t)
{
return TypeSizes.sizeof(ConsensusMigrationTarget.accord.value)
+ Epoch.messageSerializer.serializedSize(t.migratedAtEpoch, version);
+ Epoch.serializer.serializedSize(t.migratedAtEpoch);
}
});

8
src/java/org/apache/cassandra/service/paxos/PaxosPrepare.java
View File

@ -1291,7 +1291,7 @@ public class PaxosPrepare extends PaxosRequestCallback<PaxosPrepare.Response> im
promised.supersededBy.serialize(out);
}
if (version >= MessagingService.VERSION_51)
ConsensusMigratedAt.serializer.serialize(response.maybeConsenusMigratedAt, out, version);
ConsensusMigratedAt.serializer.serialize(response.maybeConsenusMigratedAt, out);
}
public Response deserialize(DataInputPlus in, int version) throws IOException
@ -1302,7 +1302,7 @@ public class PaxosPrepare extends PaxosRequestCallback<PaxosPrepare.Response> im
Ballot supersededBy = Ballot.deserialize(in);
ConsensusMigratedAt consensusMigratedAt = null;
if (version >= MessagingService.VERSION_51)
consensusMigratedAt = ConsensusMigratedAt.serializer.deserialize(in, version);
consensusMigratedAt = ConsensusMigratedAt.serializer.deserialize(in);
return new Rejected(supersededBy, consensusMigratedAt);
}
else
@ -1320,7 +1320,7 @@ public class PaxosPrepare extends PaxosRequestCallback<PaxosPrepare.Response> im
supersededBy = Ballot.deserialize(in);
ConsensusMigratedAt consensusMigratedAt = null;
if (version >= MessagingService.VERSION_51)
consensusMigratedAt = ConsensusMigratedAt.serializer.deserialize(in, version);
consensusMigratedAt = ConsensusMigratedAt.serializer.deserialize(in);
return new Permitted(outcome, consensusMigratedAt, lowBound, acceptedNotCommitted, committed, readResponse, hasProposalStability, gossipInfo, electorateEpoch, supersededBy);
}
}
@ -1344,7 +1344,7 @@ public class PaxosPrepare extends PaxosRequestCallback<PaxosPrepare.Response> im
+ (permitted.outcome == PERMIT_READ ? Ballot.sizeInBytes() : 0);
}
if (version >= MessagingService.VERSION_51)
size += ConsensusMigratedAt.serializer.serializedSize(response.maybeConsenusMigratedAt, version);
size += ConsensusMigratedAt.serializer.serializedSize(response.maybeConsenusMigratedAt);
return size;
}

9
src/java/org/apache/cassandra/tcm/Epoch.java
View File

@ -26,6 +26,7 @@ import java.util.Set;
import com.google.common.collect.Sets;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.tcm.serialization.MetadataSerializer;
@ -176,34 +177,40 @@ public class Epoch implements Comparable<Epoch>, Serializable
return epoch;
}
public static class EpochSerializer implements MetadataSerializer<Epoch>
public static class EpochSerializer implements MetadataSerializer<Epoch>, UnversionedSerializer<Epoch>
{
// convenience methods for messageSerializer et al
@Override
public void serialize(Epoch t, DataOutputPlus out) throws IOException
{
serialize(t, out, Version.V0);
}
@Override
public Epoch deserialize(DataInputPlus in) throws IOException
{
return deserialize(in, Version.V0);
}
@Override
public long serializedSize(Epoch t)
{
return serializedSize(t, Version.V0);
}
@Override
public void serialize(Epoch t, DataOutputPlus out, Version version) throws IOException
{
out.writeUnsignedVInt(t.epoch);
}
@Override
public Epoch deserialize(DataInputPlus in, Version version) throws IOException
{
return Epoch.create(in.readUnsignedVInt());
}
@Override
public long serializedSize(Epoch t, Version version)
{
return VIntCoding.computeUnsignedVIntSize(t.epoch);

6
src/java/org/apache/cassandra/tcm/transformations/ReconfigureAccordFastPath.java
View File

@ -82,7 +82,7 @@ public class ReconfigureAccordFastPath implements Transformation
public void serialize(Transformation t, DataOutputPlus out, Version version) throws IOException
{
ReconfigureAccordFastPath update = (ReconfigureAccordFastPath) t;
TopologySerializers.nodeId.serialize(update.node, out, version);
TopologySerializers.nodeId.serialize(update.node, out);
AccordFastPath.Status.serializer.serialize(update.status, out, version);
out.writeUnsignedVInt(update.updateTimeMillis);
out.writeUnsignedVInt(update.updateDelayMillis);
@ -91,7 +91,7 @@ public class ReconfigureAccordFastPath implements Transformation
public ReconfigureAccordFastPath deserialize(DataInputPlus in, Version version) throws IOException
{
return new ReconfigureAccordFastPath(TopologySerializers.nodeId.deserialize(in, version),
return new ReconfigureAccordFastPath(TopologySerializers.nodeId.deserialize(in),
AccordFastPath.Status.serializer.deserialize(in, version),
in.readUnsignedVInt(), in.readUnsignedVInt());
}
@ -99,7 +99,7 @@ public class ReconfigureAccordFastPath implements Transformation
public long serializedSize(Transformation t, Version version)
{
ReconfigureAccordFastPath update = (ReconfigureAccordFastPath) t;
return TopologySerializers.nodeId.serializedSize(update.node, version) +
return TopologySerializers.nodeId.serializedSize(update.node) +
AccordFastPath.Status.serializer.serializedSize(update.status, version) +
TypeSizes.sizeofUnsignedVInt(update.updateTimeMillis) +
TypeSizes.sizeofUnsignedVInt(update.updateDelayMillis);

50
src/java/org/apache/cassandra/utils/ArraySerializers.java
View File

@ -21,7 +21,9 @@ package org.apache.cassandra.utils;
import java.io.IOException;
import java.util.function.IntFunction;
import org.apache.cassandra.io.AsymmetricVersionedSerializer;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
@ -29,6 +31,13 @@ import static org.apache.cassandra.db.TypeSizes.sizeofUnsignedVInt;
public class ArraySerializers
{
public static <T> void serializeArray(T[] items, DataOutputPlus out, UnversionedSerializer<T> serializer) throws IOException
{
out.writeUnsignedVInt32(items.length);
for (T item : items)
serializer.serialize(item, out);
}
public static <T> void serializeArray(T[] items, DataOutputPlus out, int version, IVersionedSerializer<T> serializer) throws IOException
{
out.writeUnsignedVInt32(items.length);
@ -36,6 +45,22 @@ public class ArraySerializers
serializer.serialize(item, out, version);
}
public static <T, Version> void serializeArray(T[] items, DataOutputPlus out, Version version, AsymmetricVersionedSerializer<T, ?, Version> serializer) throws IOException
{
out.writeUnsignedVInt32(items.length);
for (T item : items)
serializer.serialize(item, out, version);
}
public static <T> T[] deserializeArray(DataInputPlus in, UnversionedSerializer<T> serializer, IntFunction<T[]> arrayFactory) throws IOException
{
int size = in.readUnsignedVInt32();
T[] items = arrayFactory.apply(size);
for (int i = 0; i < size; i++)
items[i] = serializer.deserialize(in);
return items;
}
public static <T> T[] deserializeArray(DataInputPlus in, int version, IVersionedSerializer<T> serializer, IntFunction<T[]> arrayFactory) throws IOException
{
int size = in.readUnsignedVInt32();
@ -45,6 +70,23 @@ public class ArraySerializers
return items;
}
public static <T, Version> T[] deserializeArray(DataInputPlus in, Version version, AsymmetricVersionedSerializer<?, T, Version> serializer, IntFunction<T[]> arrayFactory) throws IOException
{
int size = in.readUnsignedVInt32();
T[] items = arrayFactory.apply(size);
for (int i = 0; i < size; i++)
items[i] = serializer.deserialize(in, version);
return items;
}
public static <T> long serializedArraySize(T[] array, UnversionedSerializer<T> serializer)
{
long size = sizeofUnsignedVInt(array.length);
for (T item : array)
size += serializer.serializedSize(item);
return size;
}
public static <T> long serializedArraySize(T[] array, int version, IVersionedSerializer<T> serializer)
{
long size = sizeofUnsignedVInt(array.length);
@ -52,4 +94,12 @@ public class ArraySerializers
size += serializer.serializedSize(item, version);
return size;
}
public static <T, Version> long serializedArraySize(T[] array, Version version, AsymmetricVersionedSerializer<T, ?, Version> serializer)
{
long size = sizeofUnsignedVInt(array.length);
for (T item : array)
size += serializer.serializedSize(item, version);
return size;
}
}

10
src/java/org/apache/cassandra/utils/BooleanSerializer.java
View File

@ -20,24 +20,26 @@ package org.apache.cassandra.utils;
import java.io.IOException;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public class BooleanSerializer implements IVersionedSerializer<Boolean>
public class BooleanSerializer implements UnversionedSerializer<Boolean>
{
public static BooleanSerializer serializer = new BooleanSerializer();
public static IVersionedSerializer<Boolean> messagingSerializer = IVersionedSerializer.from(serializer);
public void serialize(Boolean b, DataOutputPlus out, int version) throws IOException
public void serialize(Boolean b, DataOutputPlus out) throws IOException
{
out.writeBoolean(b);
}
public Boolean deserialize(DataInputPlus in, int version) throws IOException
public Boolean deserialize(DataInputPlus in) throws IOException
{
return in.readBoolean();
}
public long serializedSize(Boolean aBoolean, int version)
public long serializedSize(Boolean aBoolean)
{
return 1;
}

26
src/java/org/apache/cassandra/utils/ByteBufferUtil.java
View File

@ -54,10 +54,9 @@ import org.apache.cassandra.db.marshal.ListType;
import org.apache.cassandra.db.marshal.MapType;
import org.apache.cassandra.db.marshal.SetType;
import org.apache.cassandra.db.marshal.TimestampType;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.compress.BufferType;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputBuffer;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.io.util.FileUtils;
@ -1020,19 +1019,6 @@ public class ByteBufferUtil
}
}
public static <T> ByteBuffer serialized(IVersionedSerializer<T> serializer, T value, int version)
{
try (DataOutputBuffer dob = new DataOutputBuffer())
{
serializer.serialize(value, dob, version);
return dob.buffer();
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
public static void writeLeastSignificantBytes(long register, int bytes, ByteBuffer out)
{
writeMostSignificantBytes(register << ((8 - bytes)*8), bytes, out);
@ -1131,26 +1117,26 @@ public class ByteBufferUtil
}
}
public static final IVersionedSerializer<ByteBuffer> byteBufferSerializer = new IVersionedSerializer<ByteBuffer>()
public static final UnversionedSerializer<ByteBuffer> byteBufferSerializer = new UnversionedSerializer<ByteBuffer>()
{
@Override
public void serialize(ByteBuffer bytes, DataOutputPlus out, int version) throws IOException
public void serialize(ByteBuffer bytes, DataOutputPlus out) throws IOException
{
writeWithVIntLength(bytes, out);
}
@Override
public ByteBuffer deserialize(DataInputPlus in, int version) throws IOException
public ByteBuffer deserialize(DataInputPlus in) throws IOException
{
return readWithVIntLength(in);
}
@Override
public long serializedSize(ByteBuffer bytes, int version)
public long serializedSize(ByteBuffer bytes)
{
return serializedSizeWithVIntLength(bytes);
}
};
public static final IVersionedSerializer<ByteBuffer> nullableByteBufferSerializer = NullableSerializer.wrap(byteBufferSerializer);
public static final UnversionedSerializer<ByteBuffer> nullableByteBufferSerializer = NullableSerializer.wrap(byteBufferSerializer);
}

89
src/java/org/apache/cassandra/utils/CastingSerializer.java
View File

@ -20,45 +20,90 @@ package org.apache.cassandra.utils;
import java.io.IOException;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.VersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
/**
* Utility for serializing/deserializing from/into generic interface fields where we know (and require) the
* generic fields to be implementation specific classes
* @param <Generic>
* @param <Specific>
*/
public class CastingSerializer<Generic, Specific extends Generic> implements IVersionedSerializer<Generic>
public class CastingSerializer
{
private final Class<Specific> specificClass;
private final IVersionedSerializer<Specific> specificSerializer;
public CastingSerializer(Class<Specific> specificClass, IVersionedSerializer<Specific> specificSerializer)
public static <Generic, Specific extends Generic, Version> VersionedSerializer<Generic, Version> create(Class<Specific> specificClass, VersionedSerializer<Specific, Version> specificSerializer)
{
this.specificClass = specificClass;
this.specificSerializer = specificSerializer;
return new Versioned<>(specificClass, specificSerializer);
}
@Override
public void serialize(Generic generic, DataOutputPlus out, int version) throws IOException
public static <Generic, Specific extends Generic> UnversionedSerializer<Generic> create(Class<Specific> specificClass, UnversionedSerializer<Specific> specificSerializer)
{
specificSerializer.serialize(specificClass.cast(generic), out, version);
return new Unversioned<>(specificClass, specificSerializer);
}
@Override
public Generic deserialize(DataInputPlus in, int version) throws IOException
private static final class Versioned<Generic, Specific extends Generic, Version> implements VersionedSerializer<Generic, Version>
{
Generic result = specificSerializer.deserialize(in, version);
if (result != null && !specificClass.isInstance(result))
throw new IllegalStateException("Expected instance of " + specificClass.getName());
return result;
private final Class<Specific> specificClass;
private final VersionedSerializer<Specific, Version> specificSerializer;
private Versioned(Class<Specific> specificClass, VersionedSerializer<Specific, Version> specificSerializer)
{
this.specificClass = specificClass;
this.specificSerializer = specificSerializer;
}
@Override
public void serialize(Generic generic, DataOutputPlus out, Version version) throws IOException
{
specificSerializer.serialize(specificClass.cast(generic), out, version);
}
@Override
public Generic deserialize(DataInputPlus in, Version version) throws IOException
{
Generic result = specificSerializer.deserialize(in, version);
if (result != null && !specificClass.isInstance(result))
throw new IllegalStateException("Expected instance of " + specificClass.getName());
return result;
}
@Override
public long serializedSize(Generic generic, Version version)
{
return specificSerializer.serializedSize(specificClass.cast(generic), version);
}
}
@Override
public long serializedSize(Generic generic, int version)
private static final class Unversioned<Generic, Specific extends Generic> implements UnversionedSerializer<Generic>
{
return specificSerializer.serializedSize(specificClass.cast(generic), version);
private final Class<Specific> specificClass;
private final UnversionedSerializer<Specific> specificSerializer;
private Unversioned(Class<Specific> specificClass, UnversionedSerializer<Specific> specificSerializer)
{
this.specificClass = specificClass;
this.specificSerializer = specificSerializer;
}
@Override
public void serialize(Generic generic, DataOutputPlus out) throws IOException
{
specificSerializer.serialize(specificClass.cast(generic), out);
}
@Override
public Generic deserialize(DataInputPlus in) throws IOException
{
Generic result = specificSerializer.deserialize(in);
if (result != null && !specificClass.isInstance(result))
throw new IllegalStateException("Expected instance of " + specificClass.getName());
return result;
}
@Override
public long serializedSize(Generic generic)
{
return specificSerializer.serializedSize(specificClass.cast(generic));
}
}
}

353
src/java/org/apache/cassandra/utils/CollectionSerializers.java
View File

@ -34,7 +34,10 @@ import com.google.common.collect.Sets;
import accord.utils.SortedArrays.SortedArrayList;
import org.apache.cassandra.dht.IPartitioner;
import org.apache.cassandra.dht.IPartitionerDependentSerializer;
import org.apache.cassandra.io.AsymmetricVersionedSerializer;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.VersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.tcm.serialization.MetadataSerializer;
@ -44,6 +47,13 @@ import static org.apache.cassandra.db.TypeSizes.sizeofUnsignedVInt;
public class CollectionSerializers
{
public static <V> void serializeCollection(Collection<V> values, DataOutputPlus out, UnversionedSerializer<V> valueSerializer) throws IOException
{
out.writeUnsignedVInt32(values.size());
for (V value : values)
valueSerializer.serialize(value, out);
}
public static <V> void serializeCollection(Collection<V> values, DataOutputPlus out, int version, IVersionedSerializer<V> valueSerializer) throws IOException
{
out.writeUnsignedVInt32(values.size());
@ -51,6 +61,13 @@ public class CollectionSerializers
valueSerializer.serialize(value, out, version);
}
public static <V, Version> void serializeCollection(Collection<V> values, DataOutputPlus out, Version version, AsymmetricVersionedSerializer<V, ?, Version> valueSerializer) throws IOException
{
out.writeUnsignedVInt32(values.size());
for (V value : values)
valueSerializer.serialize(value, out, version);
}
public static <V> void serializeCollection(Collection<V> values, DataOutputPlus out, Version version, MetadataSerializer<V> valueSerializer) throws IOException
{
out.writeUnsignedVInt32(values.size());
@ -65,6 +82,14 @@ public class CollectionSerializers
valueSerializer.serialize(value, out, version);
}
public static <V, L extends List<V>> void serializeList(L values, DataOutputPlus out, UnversionedSerializer<V> valueSerializer) throws IOException
{
int size = values.size();
out.writeUnsignedVInt32(size);
for (int i = 0 ; i < size ; ++i)
valueSerializer.serialize(values.get(i), out);
}
public static <V, L extends List<V>> void serializeList(L values, DataOutputPlus out, int version, IVersionedSerializer<V> valueSerializer) throws IOException
{
int size = values.size();
@ -73,17 +98,33 @@ public class CollectionSerializers
valueSerializer.serialize(values.get(i), out, version);
}
public static <K, V> void serializeMap(Map<K, V> map, DataOutputPlus out, int version, IVersionedSerializer<K> keySerializer, IVersionedSerializer<V> valueSerializer) throws IOException
public static <V, L extends List<V>, Version> void serializeList(L values, DataOutputPlus out, Version version, AsymmetricVersionedSerializer<V, ?, Version> valueSerializer) throws IOException
{
int size = values.size();
out.writeUnsignedVInt32(size);
for (int i = 0 ; i < size ; ++i)
valueSerializer.serialize(values.get(i), out, version);
}
public static <V, L extends List<V>> void serializeList(L values, DataOutputPlus out, Version version, MetadataSerializer<V> valueSerializer) throws IOException
{
int size = values.size();
out.writeUnsignedVInt32(size);
for (int i = 0 ; i < size ; ++i)
valueSerializer.serialize(values.get(i), out, version);
}
public static <K, V> void serializeMap(Map<K, V> map, DataOutputPlus out, UnversionedSerializer<K> keySerializer, UnversionedSerializer<V> valueSerializer) throws IOException
{
out.writeUnsignedVInt32(map.size());
for (Map.Entry<K, V> e : map.entrySet())
{
keySerializer.serialize(e.getKey(), out, version);
valueSerializer.serialize(e.getValue(), out, version);
keySerializer.serialize(e.getKey(), out);
valueSerializer.serialize(e.getValue(), out);
}
}
public static <K, V> void serializeMap(Map<K, V> map, DataOutputPlus out, Version version, MetadataSerializer<K> keySerializer, MetadataSerializer<V> valueSerializer) throws IOException
public static <K, V> void serializeMap(Map<K, V> map, DataOutputPlus out, int version, IVersionedSerializer<K> keySerializer, IVersionedSerializer<V> valueSerializer) throws IOException
{
out.writeUnsignedVInt32(map.size());
for (Map.Entry<K, V> e : map.entrySet())
@ -103,20 +144,50 @@ public class CollectionSerializers
}
}
public static <V extends Comparable<? super V>> SortedArrayList<V> deserializeSortedArrayList(DataInputPlus in, int version, IVersionedSerializer<V> serializer, IntFunction<V[]> allocator) throws IOException
public static <K, V, Version> void serializeMap(Map<K, V> map, DataOutputPlus out, Version version, AsymmetricVersionedSerializer<K, ?, Version> keySerializer, AsymmetricVersionedSerializer<V, ?, Version> valueSerializer) throws IOException
{
out.writeUnsignedVInt32(map.size());
for (Map.Entry<K, V> e : map.entrySet())
{
keySerializer.serialize(e.getKey(), out, version);
valueSerializer.serialize(e.getValue(), out, version);
}
}
public static <K, V> void serializeMap(Map<K, V> map, DataOutputPlus out, Version version, MetadataSerializer<K> keySerializer, MetadataSerializer<V> valueSerializer) throws IOException
{
out.writeUnsignedVInt32(map.size());
for (Map.Entry<K, V> e : map.entrySet())
{
keySerializer.serialize(e.getKey(), out, version);
valueSerializer.serialize(e.getValue(), out, version);
}
}
public static <V extends Comparable<? super V>> SortedArrayList<V> deserializeSortedArrayList(DataInputPlus in, UnversionedSerializer<V> serializer, IntFunction<V[]> allocator) throws IOException
{
int size = in.readUnsignedVInt32();
V[] array = allocator.apply(size);
for (int i = 0 ; i < array.length ; ++i)
array[i] = serializer.deserialize(in, version);
array[i] = serializer.deserialize(in);
return new SortedArrayList<>(array);
}
public static <V> List<V> deserializeList(DataInputPlus in, UnversionedSerializer<V> serializer) throws IOException
{
return deserializeCollection(in, serializer, newArrayList());
}
public static <V> List<V> deserializeList(DataInputPlus in, int version, IVersionedSerializer<V> serializer) throws IOException
{
return deserializeCollection(in, version, serializer, newArrayList());
}
public static <V, Version> List<V> deserializeList(DataInputPlus in, Version version, AsymmetricVersionedSerializer<?, V, Version> serializer) throws IOException
{
return deserializeCollection(in, version, serializer, newArrayList());
}
public static <V> List<V> deserializeList(DataInputPlus in, Version version, MetadataSerializer<V> serializer) throws IOException
{
return deserializeCollection(in, version, serializer, newArrayList());
@ -127,6 +198,11 @@ public class CollectionSerializers
return deserializeCollection(in, partitioner, version, serializer, newArrayList());
}
public static <V> Set<V> deserializeSet(DataInputPlus in, UnversionedSerializer<V> serializer) throws IOException
{
return deserializeCollection(in, serializer, newHashSet());
}
public static <V> Set<V> deserializeSet(DataInputPlus in, int version, IVersionedSerializer<V> serializer) throws IOException
{
return deserializeCollection(in, version, serializer, newHashSet());
@ -137,11 +213,29 @@ public class CollectionSerializers
return deserializeCollection(in, partitioner, version, serializer, newHashSet());
}
public static <V, Version> Set<V> deserializeSet(DataInputPlus in, Version version, AsymmetricVersionedSerializer<?, V, Version> serializer) throws IOException
{
return deserializeCollection(in, version, serializer, newHashSet());
}
public static <V> Set<V> deserializeSet(DataInputPlus in, Version version, MetadataSerializer<V> serializer) throws IOException
{
return deserializeCollection(in, version, serializer, newHashSet());
}
public static <K, V, M extends Map<K, V>> M deserializeMap(DataInputPlus in, UnversionedSerializer<K> keySerializer, UnversionedSerializer<V> valueSerializer, IntFunction<M> factory) throws IOException
{
int size = in.readUnsignedVInt32();
M result = factory.apply(size);
while (size-- > 0)
{
K key = keySerializer.deserialize(in);
V value = valueSerializer.deserialize(in);
result.put(key, value);
}
return result;
}
public static <K, V, M extends Map<K, V>> M deserializeMap(DataInputPlus in, int version, IVersionedSerializer<K> keySerializer, IVersionedSerializer<V> valueSerializer, IntFunction<M> factory) throws IOException
{
int size = in.readUnsignedVInt32();
@ -155,19 +249,6 @@ public class CollectionSerializers
return result;
}
public static <K, V> Map<K,V> deserializeMap(DataInputPlus in, Version version, MetadataSerializer<K> keySerializer, MetadataSerializer<V> valueSerializer, IntFunction<Map<K,V>> factory) throws IOException
{
int size = in.readUnsignedVInt32();
Map<K,V> result = factory.apply(size);
while (size-- > 0)
{
K key = keySerializer.deserialize(in, version);
V value = valueSerializer.deserialize(in, version);
result.put(key, value);
}
return result;
}
public static <K, V> Map<K,V> deserializeMap(DataInputPlus in, IPartitioner partitioner, int version, IVersionedSerializer<K> keySerializer, IPartitionerDependentSerializer<V> valueSerializer, IntFunction<Map<K,V>> factory) throws IOException
{
int size = in.readUnsignedVInt32();
@ -181,20 +262,61 @@ public class CollectionSerializers
return result;
}
public static <K, V, M extends Map<K, V>, Version> M deserializeMap(DataInputPlus in, Version version, AsymmetricVersionedSerializer<?, K, Version> keySerializer, AsymmetricVersionedSerializer<?, V, Version> valueSerializer, IntFunction<M> factory) throws IOException
{
int size = in.readUnsignedVInt32();
M result = factory.apply(size);
while (size-- > 0)
{
K key = keySerializer.deserialize(in, version);
V value = valueSerializer.deserialize(in, version);
result.put(key, value);
}
return result;
}
public static <K, V, M extends Map<K, V>> M deserializeMap(DataInputPlus in, Version version, MetadataSerializer<K> keySerializer, MetadataSerializer<V> valueSerializer, IntFunction<M> factory) throws IOException
{
int size = in.readUnsignedVInt32();
M result = factory.apply(size);
while (size-- > 0)
{
K key = keySerializer.deserialize(in, version);
V value = valueSerializer.deserialize(in, version);
result.put(key, value);
}
return result;
}
public static <K, V> Map<K, V> deserializeMap(DataInputPlus in, UnversionedSerializer<K> keySerializer, UnversionedSerializer<V> valueSerializer) throws IOException
{
return deserializeMap(in, keySerializer, valueSerializer, Maps::newHashMapWithExpectedSize);
}
public static <K, V> Map<K, V> deserializeMap(DataInputPlus in, int version, IVersionedSerializer<K> keySerializer, IVersionedSerializer<V> valueSerializer) throws IOException
{
return deserializeMap(in, version, keySerializer, valueSerializer, Maps::newHashMapWithExpectedSize);
}
public static <V> long serializedCollectionSize(Collection<V> values, int version, IVersionedSerializer<V> valueSerializer)
public static <K, V, Version> Map<K, V> deserializeMap(DataInputPlus in, Version version, AsymmetricVersionedSerializer<?, K, Version> keySerializer, AsymmetricVersionedSerializer<?, V, Version> valueSerializer) throws IOException
{
return deserializeMap(in, version, keySerializer, valueSerializer, Maps::newHashMapWithExpectedSize);
}
public static <K, V> Map<K, V> deserializeMap(DataInputPlus in, Version version, MetadataSerializer<K> keySerializer, MetadataSerializer<V> valueSerializer) throws IOException
{
return deserializeMap(in, version, keySerializer, valueSerializer, Maps::newHashMapWithExpectedSize);
}
public static <V> long serializedCollectionSize(Collection<V> values, UnversionedSerializer<V> valueSerializer)
{
long size = sizeofUnsignedVInt(values.size());
for (V value : values)
size += valueSerializer.serializedSize(value, version);
size += valueSerializer.serializedSize(value);
return size;
}
public static <V> long serializedCollectionSize(Collection<V> values, Version version, MetadataSerializer<V> valueSerializer)
public static <V> long serializedCollectionSize(Collection<V> values, int version, IVersionedSerializer<V> valueSerializer)
{
long size = sizeofUnsignedVInt(values.size());
for (V value : values)
@ -210,6 +332,31 @@ public class CollectionSerializers
return size;
}
public static <V, Version> long serializedCollectionSize(Collection<V> values, Version version, AsymmetricVersionedSerializer<V, ?, Version> valueSerializer)
{
long size = sizeofUnsignedVInt(values.size());
for (V value : values)
size += valueSerializer.serializedSize(value, version);
return size;
}
public static <V> long serializedCollectionSize(Collection<V> values, Version version, MetadataSerializer<V> valueSerializer)
{
long size = sizeofUnsignedVInt(values.size());
for (V value : values)
size += valueSerializer.serializedSize(value, version);
return size;
}
public static <V, L extends List<V>> long serializedListSize(L values, UnversionedSerializer<V> valueSerializer)
{
int items = values.size();
long size = sizeofUnsignedVInt(items);
for (int i = 0 ; i < items ; ++i)
size += valueSerializer.serializedSize(values.get(i));
return size;
}
public static <V, L extends List<V>> long serializedListSize(L values, int version, IVersionedSerializer<V> valueSerializer)
{
int items = values.size();
@ -219,6 +366,33 @@ public class CollectionSerializers
return size;
}
public static <V, L extends List<V>, Version> long serializedListSize(L values, Version version, AsymmetricVersionedSerializer<V, ?, Version> valueSerializer)
{
int items = values.size();
long size = sizeofUnsignedVInt(items);
for (int i = 0 ; i < items ; ++i)
size += valueSerializer.serializedSize(values.get(i), version);
return size;
}
public static <V, L extends List<V>> long serializedListSize(L values, Version version, MetadataSerializer<V> valueSerializer)
{
int items = values.size();
long size = sizeofUnsignedVInt(items);
for (int i = 0 ; i < items ; ++i)
size += valueSerializer.serializedSize(values.get(i), version);
return size;
}
public static <K, V> long serializedMapSize(Map<K, V> map, UnversionedSerializer<K> keySerializer, UnversionedSerializer<V> valueSerializer)
{
long size = sizeofUnsignedVInt(map.size());
for (Map.Entry<K, V> e : map.entrySet())
size += keySerializer.serializedSize(e.getKey())
+ valueSerializer.serializedSize(e.getValue());
return size;
}
public static <K, V> long serializedMapSize(Map<K, V> map, int version, IVersionedSerializer<K> keySerializer, IVersionedSerializer<V> valueSerializer)
{
long size = sizeofUnsignedVInt(map.size());
@ -228,7 +402,7 @@ public class CollectionSerializers
return size;
}
public static <K, V> long serializedMapSize(Map<K, V> map, Version version, MetadataSerializer<K> keySerializer, MetadataSerializer<V> valueSerializer)
public static <K, V> long serializedMapSize(Map<K, V> map, int version, IVersionedSerializer<K> keySerializer, IPartitionerDependentSerializer<V> valueSerializer)
{
long size = sizeofUnsignedVInt(map.size());
for (Map.Entry<K, V> e : map.entrySet())
@ -237,7 +411,16 @@ public class CollectionSerializers
return size;
}
public static <K, V> long serializedMapSize(Map<K, V> map, int version, IVersionedSerializer<K> keySerializer, IPartitionerDependentSerializer<V> valueSerializer)
public static <K, V, Version> long serializedMapSize(Map<K, V> map, Version version, AsymmetricVersionedSerializer<K, ?, Version> keySerializer, AsymmetricVersionedSerializer<V, ?, Version> valueSerializer)
{
long size = sizeofUnsignedVInt(map.size());
for (Map.Entry<K, V> e : map.entrySet())
size += keySerializer.serializedSize(e.getKey(), version)
+ valueSerializer.serializedSize(e.getValue(), version);
return size;
}
public static <K, V> long serializedMapSize(Map<K, V> map, Version version, MetadataSerializer<K> keySerializer, MetadataSerializer<V> valueSerializer)
{
long size = sizeofUnsignedVInt(map.size());
for (Map.Entry<K, V> e : map.entrySet())
@ -266,6 +449,19 @@ public class CollectionSerializers
return in.readUnsignedVInt32();
}
/*
* Private to push auto-complete to the convenience methods
* Feel free to make public if there is a weird collection you want to use
*/
private static <V, C extends Collection<? super V>> C deserializeCollection(DataInputPlus in, UnversionedSerializer<V> serializer, IntFunction<C> factory) throws IOException
{
int size = in.readUnsignedVInt32();
C result = factory.apply(size);
while (size-- > 0)
result.add(serializer.deserialize(in));
return result;
}
/*
* Private to push auto-complete to the convenience methods
* Feel free to make public if there is a weird collection you want to use
@ -279,6 +475,57 @@ public class CollectionSerializers
return result;
}
private static <V, C extends Collection<? super V>> C deserializeCollection(DataInputPlus in, IPartitioner partitioner, int version, IPartitionerDependentSerializer<V> serializer, IntFunction<C> factory) throws IOException
{
int size = in.readUnsignedVInt32();
C result = factory.apply(size);
while (size-- > 0)
result.add(serializer.deserialize(in, partitioner, version));
return result;
}
private static <V, C extends Collection<? super V>, Version> C deserializeCollection(DataInputPlus in, Version version, AsymmetricVersionedSerializer<?, V, Version> serializer, IntFunction<C> factory) throws IOException
{
int size = in.readUnsignedVInt32();
C result = factory.apply(size);
while (size-- > 0)
result.add(serializer.deserialize(in, version));
return result;
}
private static <V, C extends Collection<? super V>> C deserializeCollection(DataInputPlus in, Version version, MetadataSerializer<V> serializer, IntFunction<C> factory) throws IOException
{
int size = in.readUnsignedVInt32();
C result = factory.apply(size);
while (size-- > 0)
result.add(serializer.deserialize(in, version));
return result;
}
public static <V> UnversionedSerializer<List<V>> newListSerializer(UnversionedSerializer<V> itemSerializer)
{
return new UnversionedSerializer<List<V>>()
{
@Override
public void serialize(List<V> list, DataOutputPlus out) throws IOException
{
serializeList(list, out, itemSerializer);
}
@Override
public List<V> deserialize(DataInputPlus in) throws IOException
{
return deserializeList(in, itemSerializer);
}
@Override
public long serializedSize(List<V> t)
{
return serializedListSize(t, itemSerializer);
}
};
}
public static <V> IVersionedSerializer<List<V>> newListSerializer(IVersionedSerializer<V> itemSerializer)
{
return new IVersionedSerializer<List<V>>()
@ -303,22 +550,28 @@ public class CollectionSerializers
};
}
private static <V, C extends Collection<? super V>> C deserializeCollection(DataInputPlus in, IPartitioner partitioner, int version, IPartitionerDependentSerializer<V> serializer, IntFunction<C> factory) throws IOException
public static <T, Version> VersionedSerializer<List<T>, Version> newListSerializer(@Nonnull final VersionedSerializer<T, Version> serializer)
{
int size = in.readUnsignedVInt32();
C result = factory.apply(size);
while (size-- > 0)
result.add(serializer.deserialize(in, partitioner, version));
return result;
}
return new VersionedSerializer<List<T>, Version>()
{
@Override
public void serialize(List<T> t, DataOutputPlus out, Version version) throws IOException
{
serializeCollection(t, out, version, serializer);
}
private static <V, C extends Collection<? super V>> C deserializeCollection(DataInputPlus in, Version version, MetadataSerializer<V> serializer, IntFunction<C> factory) throws IOException
{
int size = in.readUnsignedVInt32();
C result = factory.apply(size);
while (size-- > 0)
result.add(serializer.deserialize(in, version));
return result;
@Override
public List<T> deserialize(DataInputPlus in, Version version) throws IOException
{
return deserializeList(in, version, serializer);
}
@Override
public long serializedSize(List<T> t, Version version)
{
return serializedCollectionSize(t, version, serializer);
}
};
}
public static <T> IPartitionerDependentSerializer<Collection<T>> newCollectionSerializer(@Nonnull final IPartitionerDependentSerializer<T> serializer)
@ -344,28 +597,4 @@ public class CollectionSerializers
}
};
}
public static <T> MetadataSerializer<List<T>> newListSerializer(@Nonnull final MetadataSerializer<T> serializer)
{
return new MetadataSerializer<List<T>>()
{
@Override
public void serialize(List<T> t, DataOutputPlus out, Version version) throws IOException
{
serializeCollection(t, out, version, serializer);
}
@Override
public List<T> deserialize(DataInputPlus in, Version version) throws IOException
{
return deserializeList(in, version, serializer);
}
@Override
public long serializedSize(List<T> t, Version version)
{
return serializedCollectionSize(t, version, serializer);
}
};
}
}

27
src/java/org/apache/cassandra/utils/Int32Serializer.java
View File

@ -22,25 +22,44 @@ import java.io.IOException;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public class Int32Serializer implements IVersionedSerializer<Integer>
public class Int32Serializer implements UnversionedSerializer<Integer>, IVersionedSerializer<Integer>
{
public static final Int32Serializer serializer = new Int32Serializer();
public void serialize(Integer t, DataOutputPlus out, int version) throws IOException
public void serialize(Integer t, DataOutputPlus out) throws IOException
{
out.writeInt(t);
}
public Integer deserialize(DataInputPlus in, int version) throws IOException
@Override
public void serialize(Integer t, DataOutputPlus out, int version) throws IOException
{
serialize(t, out);
}
public Integer deserialize(DataInputPlus in) throws IOException
{
return in.readInt();
}
public long serializedSize(Integer t, int version)
@Override
public Integer deserialize(DataInputPlus in, int version) throws IOException
{
return deserialize(in);
}
public long serializedSize(Integer t)
{
return TypeSizes.sizeof(t.intValue());
}
@Override
public long serializedSize(Integer t, int version)
{
return serializedSize(t);
}
}

87
src/java/org/apache/cassandra/utils/NullableSerializer.java
View File

@ -22,11 +22,20 @@ import java.io.IOException;
import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.VersionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
public class NullableSerializer
{
public static <T> void serializeNullable(T value, DataOutputPlus out, UnversionedSerializer<T> serializer) throws IOException
{
out.writeBoolean(value != null);
if (value != null)
serializer.serialize(value, out);
}
public static <T> void serializeNullable(T value, DataOutputPlus out, int version, IVersionedSerializer<T> serializer) throws IOException
{
out.writeBoolean(value != null);
@ -34,11 +43,35 @@ public class NullableSerializer
serializer.serialize(value, out, version);
}
public static <T, Version> void serializeNullable(T value, DataOutputPlus out, Version version, VersionedSerializer<T, Version> serializer) throws IOException
{
out.writeBoolean(value != null);
if (value != null)
serializer.serialize(value, out, version);
}
public static <T> T deserializeNullable(DataInputPlus in, UnversionedSerializer<T> serializer) throws IOException
{
return in.readBoolean() ? serializer.deserialize(in) : null;
}
public static <T> T deserializeNullable(DataInputPlus in, int version, IVersionedSerializer<T> serializer) throws IOException
{
return in.readBoolean() ? serializer.deserialize(in, version) : null;
}
public static <T, Version> T deserializeNullable(DataInputPlus in, Version version, VersionedSerializer<T, Version> serializer) throws IOException
{
return in.readBoolean() ? serializer.deserialize(in, version) : null;
}
public static <T> long serializedNullableSize(T value, UnversionedSerializer<T> serializer)
{
return value != null
? TypeSizes.sizeof(true) + serializer.serializedSize(value)
: TypeSizes.sizeof(false);
}
public static <T> long serializedNullableSize(T value, int version, IVersionedSerializer<T> serializer)
{
return value != null
@ -46,6 +79,37 @@ public class NullableSerializer
: TypeSizes.sizeof(false);
}
public static <T, Version> long serializedNullableSize(T value, Version version, VersionedSerializer<T, Version> serializer)
{
return value != null
? TypeSizes.sizeof(true) + serializer.serializedSize(value, version)
: TypeSizes.sizeof(false);
}
public static <T> UnversionedSerializer<T> wrap(UnversionedSerializer<T> wrap)
{
return new UnversionedSerializer<>()
{
@Override
public void serialize(T t, DataOutputPlus out) throws IOException
{
serializeNullable(t, out, wrap);
}
@Override
public T deserialize(DataInputPlus in) throws IOException
{
return deserializeNullable(in, wrap);
}
@Override
public long serializedSize(T t)
{
return serializedNullableSize(t, wrap);
}
};
}
public static <T> IVersionedSerializer<T> wrap(IVersionedSerializer<T> wrap)
{
return new IVersionedSerializer<T>() {
@ -65,4 +129,27 @@ public class NullableSerializer
}
};
}
public static <T, Version> VersionedSerializer<T, Version> wrap(VersionedSerializer<T, Version> wrap)
{
return new VersionedSerializer<>() {
@Override
public void serialize(T t, DataOutputPlus out, Version version) throws IOException
{
serializeNullable(t, out, version, wrap);
}
@Override
public T deserialize(DataInputPlus in, Version version) throws IOException
{
return deserializeNullable(in, version, wrap);
}
@Override
public long serializedSize(T t, Version version)
{
return serializedNullableSize(t, version, wrap);
}
};
}
}

21
src/java/org/apache/cassandra/utils/TimeUUID.java
View File

@ -46,6 +46,7 @@ import com.google.common.hash.Hashing;
import org.apache.cassandra.config.DatabaseDescriptor;
import org.apache.cassandra.db.marshal.ValueAccessor;
import org.apache.cassandra.io.IVersionedSerializer;
import org.apache.cassandra.io.UnversionedSerializer;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;
import org.apache.cassandra.locator.InetAddressAndPort;
@ -361,7 +362,7 @@ public class TimeUUID implements Serializable, Comparable<TimeUUID>
}
}
public static class Serializer extends AbstractSerializer<TimeUUID> implements IVersionedSerializer<TimeUUID>
public static class Serializer extends AbstractSerializer<TimeUUID> implements IVersionedSerializer<TimeUUID>, UnversionedSerializer<TimeUUID>
{
public static final Serializer instance = new Serializer();
@ -381,17 +382,35 @@ public class TimeUUID implements Serializable, Comparable<TimeUUID>
t.serialize(out);
}
@Override
public void serialize(TimeUUID t, DataOutputPlus out) throws IOException
{
t.serialize(out);
}
@Override
public TimeUUID deserialize(DataInputPlus in, int version) throws IOException
{
return TimeUUID.deserialize(in);
}
@Override
public TimeUUID deserialize(DataInputPlus in) throws IOException
{
return TimeUUID.deserialize(in);
}
@Override
public long serializedSize(TimeUUID t, int version)
{
return 16;
}
@Override
public long serializedSize(TimeUUID t)
{
return 16;
}
}
public static class Generator

Some files were not shown because too many files have changed in this diff Show More