}
private ActorRef createTypedTransactionActor(int transactionType,
- ShardTransactionIdentifier transactionId, String transactionChainId,
- short clientVersion ) {
+ ShardTransactionIdentifier transactionId, String transactionChainId) {
return transactionActorFactory.newShardTransaction(TransactionType.fromInt(transactionType),
- transactionId, transactionChainId, clientVersion);
+ transactionId, transactionChainId);
}
private void createTransaction(CreateTransaction createTransaction) {
}
ActorRef transactionActor = createTransaction(createTransaction.getTransactionType(),
- createTransaction.getTransactionId(), createTransaction.getTransactionChainId(),
- createTransaction.getVersion());
+ createTransaction.getTransactionId(), createTransaction.getTransactionChainId());
getSender().tell(new CreateTransactionReply(Serialization.serializedActorPath(transactionActor),
createTransaction.getTransactionId(), createTransaction.getVersion()).toSerializable(), getSelf());
}
private ActorRef createTransaction(int transactionType, String remoteTransactionId,
- String transactionChainId, short clientVersion) {
+ String transactionChainId) {
ShardTransactionIdentifier transactionId = new ShardTransactionIdentifier(remoteTransactionId);
}
ActorRef transactionActor = createTypedTransactionActor(transactionType, transactionId,
- transactionChainId, clientVersion);
+ transactionChainId);
return transactionActor;
}
private final AbstractShardDataTreeTransaction<?> transaction;
public ShardReadTransaction(AbstractShardDataTreeTransaction<?> transaction, ActorRef shardActor,
- ShardStats shardStats, String transactionID, short clientTxVersion) {
- super(shardActor, shardStats, transactionID, clientTxVersion);
+ ShardStats shardStats, String transactionID) {
+ super(shardActor, shardStats, transactionID);
this.transaction = transaction;
}
*/
public class ShardReadWriteTransaction extends ShardWriteTransaction {
public ShardReadWriteTransaction(ReadWriteShardDataTreeTransaction transaction, ActorRef shardActor,
- ShardStats shardStats, String transactionID, short clientTxVersion) {
- super(transaction, shardActor, shardStats, transactionID, clientTxVersion);
+ ShardStats shardStats, String transactionID) {
+ super(transaction, shardActor, shardStats, transactionID);
}
@Override
*/
package org.opendaylight.controller.cluster.datastore;
-import com.google.common.base.Preconditions;
import akka.actor.ActorRef;
+import com.google.common.base.Preconditions;
import java.util.concurrent.ExecutionException;
import org.opendaylight.controller.cluster.datastore.identifiers.ShardTransactionIdentifier;
import org.opendaylight.controller.cluster.datastore.messages.CreateSnapshot;
"createSnapshot" + ++createSnapshotTransactionCounter);
ActorRef createSnapshotTransaction = transactionActorFactory.newShardTransaction(
- TransactionType.READ_ONLY, transactionID, "", DataStoreVersions.CURRENT_VERSION);
+ TransactionType.READ_ONLY, transactionID, "");
createSnapshotTransaction.tell(CreateSnapshot.INSTANCE, actorRef);
}
private final ActorRef shardActor;
private final ShardStats shardStats;
private final String transactionID;
- private final short clientTxVersion;
- protected ShardTransaction(ActorRef shardActor, ShardStats shardStats, String transactionID,
- short clientTxVersion) {
+ protected ShardTransaction(ActorRef shardActor, ShardStats shardStats, String transactionID) {
super("shard-tx"); //actor name override used for metering. This does not change the "real" actor name
this.shardActor = shardActor;
this.shardStats = shardStats;
this.transactionID = Preconditions.checkNotNull(transactionID);
- this.clientTxVersion = clientTxVersion;
}
public static Props props(TransactionType type, AbstractShardDataTreeTransaction<?> transaction, ActorRef shardActor,
- DatastoreContext datastoreContext, ShardStats shardStats, String transactionID, short txnClientVersion) {
+ DatastoreContext datastoreContext, ShardStats shardStats, String transactionID) {
return Props.create(new ShardTransactionCreator(type, transaction, shardActor,
- datastoreContext, shardStats, transactionID, txnClientVersion));
+ datastoreContext, shardStats, transactionID));
}
protected abstract AbstractShardDataTreeTransaction<?> getDOMStoreTransaction();
return transactionID;
}
- protected short getClientTxVersion() {
- return clientTxVersion;
- }
-
@Override
public void handleReceive(Object message) throws Exception {
if (CloseTransaction.isSerializedType(message)) {
final DatastoreContext datastoreContext;
final ShardStats shardStats;
final String transactionID;
- final short txnClientVersion;
final TransactionType type;
ShardTransactionCreator(TransactionType type, AbstractShardDataTreeTransaction<?> transaction, ActorRef shardActor,
- DatastoreContext datastoreContext, ShardStats shardStats, String transactionID, short txnClientVersion) {
+ DatastoreContext datastoreContext, ShardStats shardStats, String transactionID) {
this.transaction = Preconditions.checkNotNull(transaction);
this.shardActor = shardActor;
this.shardStats = shardStats;
this.datastoreContext = datastoreContext;
this.transactionID = Preconditions.checkNotNull(transactionID);
- this.txnClientVersion = txnClientVersion;
this.type = type;
}
switch (type) {
case READ_ONLY:
tx = new ShardReadTransaction(transaction, shardActor,
- shardStats, transactionID, txnClientVersion);
+ shardStats, transactionID);
break;
case READ_WRITE:
tx = new ShardReadWriteTransaction((ReadWriteShardDataTreeTransaction)transaction,
- shardActor, shardStats, transactionID, txnClientVersion);
+ shardActor, shardStats, transactionID);
break;
case WRITE_ONLY:
tx = new ShardWriteTransaction((ReadWriteShardDataTreeTransaction)transaction,
- shardActor, shardStats, transactionID, txnClientVersion);
+ shardActor, shardStats, transactionID);
break;
default:
throw new IllegalArgumentException("Unhandled transaction type " + type);
}
ActorRef newShardTransaction(TransactionType type, ShardTransactionIdentifier transactionID,
- String transactionChainID, short clientVersion) {
+ String transactionChainID) {
final AbstractShardDataTreeTransaction<?> transaction;
switch (type) {
case READ_ONLY:
}
return actorContext.actorOf(ShardTransaction.props(type, transaction, shardActor, datastoreContext, shardMBean,
- transactionID.getRemoteTransactionId(), clientVersion).withDispatcher(txnDispatcherPath),
+ transactionID.getRemoteTransactionId()).withDispatcher(txnDispatcherPath),
transactionID.toString());
}
}
private final ReadWriteShardDataTreeTransaction transaction;
public ShardWriteTransaction(ReadWriteShardDataTreeTransaction transaction, ActorRef shardActor,
- ShardStats shardStats, String transactionID, short clientTxVersion) {
- super(shardActor, shardStats, transactionID, clientTxVersion);
+ ShardStats shardStats, String transactionID) {
+ super(shardActor, shardStats, transactionID);
this.transaction = transaction;
}
totalBatchedModificationsReceived, batched.getTotalMessagesSent()));
}
- readyTransaction(false, batched.isDoCommitOnReady());
+ readyTransaction(false, batched.isDoCommitOnReady(), batched.getVersion());
} else {
getSender().tell(new BatchedModificationsReply(batched.getModifications().size()), getSelf());
}
}
}
- private void readyTransaction(boolean returnSerialized, boolean doImmediateCommit) {
+ private void readyTransaction(boolean returnSerialized, boolean doImmediateCommit, short clientTxVersion) {
String transactionID = getTransactionID();
LOG.debug("readyTransaction : {}", transactionID);
- getShardActor().forward(new ForwardedReadyTransaction(transactionID, getClientTxVersion(),
+ getShardActor().forward(new ForwardedReadyTransaction(transactionID, clientTxVersion,
transaction, returnSerialized, doImmediateCommit), getContext());
// The shard will handle the commit from here so we're no longer needed - self-destruct.
final ActorRef shard = createShard();
final Props props = ShardTransaction.props(RO, store.newReadOnlyTransaction("test-txn", null), shard,
- datastoreContext, shardStats, "txn", DataStoreVersions.CURRENT_VERSION);
+ datastoreContext, shardStats, "txn");
final TestActorRef<ShardTransaction> subject = TestActorRef.create(getSystem(), props,
"testNegativeReadWithReadOnlyTransactionClosed");
final ActorRef shard = createShard();
final Props props = ShardTransaction.props(RW, store.newReadWriteTransaction("test-txn", null), shard,
- datastoreContext, shardStats, "txn", DataStoreVersions.CURRENT_VERSION);
+ datastoreContext, shardStats, "txn");
final TestActorRef<ShardTransaction> subject = TestActorRef.create(getSystem(), props,
"testNegativeReadWithReadWriteTransactionClosed");
final ActorRef shard = createShard();
final Props props = ShardTransaction.props(RW, store.newReadWriteTransaction("test-txn", null), shard,
- datastoreContext, shardStats, "txn", DataStoreVersions.CURRENT_VERSION);
+ datastoreContext, shardStats, "txn");
final TestActorRef<ShardTransaction> subject = TestActorRef.create(getSystem(), props,
"testNegativeExistsWithReadWriteTransactionClosed");
}
private ActorRef newTransactionActor(TransactionType type, AbstractShardDataTreeTransaction<?> transaction, String name) {
- return newTransactionActor(type, transaction, name, DataStoreVersions.CURRENT_VERSION);
- }
-
- private ActorRef newTransactionActor(TransactionType type, AbstractShardDataTreeTransaction<?> transaction, String name, short version) {
- return newTransactionActor(type, transaction, null, name, version);
+ return newTransactionActor(type, transaction, null, name);
}
private ActorRef newTransactionActor(TransactionType type, AbstractShardDataTreeTransaction<?> transaction, ActorRef shard, String name) {
- return newTransactionActor(type, transaction, null, name, DataStoreVersions.CURRENT_VERSION);
- }
-
- private ActorRef newTransactionActor(TransactionType type, AbstractShardDataTreeTransaction<?> transaction, ActorRef shard, String name,
- short version) {
Props props = ShardTransaction.props(type, transaction, shard != null ? shard : createShard(),
- datastoreContext, shardStats, "txn", version);
+ datastoreContext, shardStats, "txn");
return getSystem().actorOf(props, name);
}
public void testNegativePerformingWriteOperationOnReadTransaction() throws Exception {
final ActorRef shard = createShard();
final Props props = ShardTransaction.props(TransactionType.READ_ONLY, readOnlyTransaction(), shard,
- datastoreContext, shardStats, "txn", DataStoreVersions.CURRENT_VERSION);
+ datastoreContext, shardStats, "txn");
final TestActorRef<ShardTransaction> transaction = TestActorRef.apply(props,getSystem());
transaction.receive(new BatchedModifications("tx1", DataStoreVersions.CURRENT_VERSION, null),
Code Review / controller.git / commitdiff