import org.opendaylight.controller.cluster.datastore.messages.RegisterChangeListenerReply;
import org.opendaylight.controller.cluster.datastore.messages.UpdateSchemaContext;
import org.opendaylight.controller.cluster.datastore.modification.Modification;
+import org.opendaylight.controller.cluster.datastore.modification.MutableCompositeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener;
import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import java.util.HashMap;
import java.util.Map;
private final InMemoryDOMDataStore store;
- private final Map<Modification, DOMStoreThreePhaseCommitCohort>
+ private final Map<Object, DOMStoreThreePhaseCommitCohort>
modificationToCohort = new HashMap<>();
private final LoggingAdapter log =
// property persistent
private final boolean persistent;
+ private SchemaContext schemaContext;
+
private Shard(String name) {
String setting = System.getProperty("shard.persistent");
public void onReceive(Object message) throws Exception {
log.debug("Received message {}", message);
+ if(!recoveryFinished()){
+ // FIXME : Properly handle recovery
+ return;
+ }
+
if (message instanceof CreateTransactionChain) {
createTransactionChain();
- } else if (message instanceof RegisterChangeListener) {
- registerChangeListener((RegisterChangeListener) message);
+ } else if (message.getClass().equals(RegisterChangeListener.SERIALIZABLE_CLASS)) {
+ registerChangeListener(RegisterChangeListener.fromSerializable(getContext().system(), message));
} else if (message instanceof UpdateSchemaContext) {
updateSchemaContext((UpdateSchemaContext) message);
} else if (message instanceof ForwardedCommitTransaction) {
handleForwardedCommit((ForwardedCommitTransaction) message);
} else if (message instanceof Persistent) {
- commit((Modification) ((Persistent) message).payload());
+ commit(((Persistent)message).payload());
} else if (message instanceof CreateTransaction) {
createTransaction((CreateTransaction) message);
} else if(message instanceof NonPersistent){
- commit((Modification) ((NonPersistent) message).payload());
+ commit(((NonPersistent)message).payload());
+ } else {
+ throw new Exception("Not recognized message in Shard::OnReceive"+message);
}
}
DOMStoreReadWriteTransaction transaction =
store.newReadWriteTransaction();
ActorRef transactionActor = getContext().actorOf(
- ShardTransaction.props(transaction, getSelf()), "shard-" + createTransaction.getTransactionId());
+ ShardTransaction.props(transaction, getSelf(), schemaContext), "shard-" + createTransaction.getTransactionId());
getSender()
- .tell(new CreateTransactionReply(transactionActor.path(), createTransaction.getTransactionId()),
+ .tell(new CreateTransactionReply(transactionActor.path().toString(), createTransaction.getTransactionId()).toSerializable(),
getSelf());
}
- private void commit(Modification modification) {
+ private void commit(Object serialized) {
+ Modification modification = MutableCompositeModification.fromSerializable(serialized, schemaContext);
DOMStoreThreePhaseCommitCohort cohort =
- modificationToCohort.remove(modification);
+ modificationToCohort.remove(serialized);
if (cohort == null) {
log.error(
"Could not find cohort for modification : " + modification);
}
private void handleForwardedCommit(ForwardedCommitTransaction message) {
+ Object serializedModification = message.getModification().toSerializable();
+
modificationToCohort
- .put(message.getModification(), message.getCohort());
+ .put(serializedModification , message.getCohort());
if(persistent) {
- getSelf().forward(Persistent.create(message.getModification()),
+ getSelf().forward(Persistent.create(serializedModification),
getContext());
} else {
- getSelf().forward(NonPersistent.create(message.getModification()),
+ getSelf().forward(NonPersistent.create(serializedModification),
getContext());
}
}
private void updateSchemaContext(UpdateSchemaContext message) {
+ this.schemaContext = message.getSchemaContext();
store.onGlobalContextUpdated(message.getSchemaContext());
}
getContext().actorOf(
DataChangeListenerRegistration.props(registration));
getSender()
- .tell(new RegisterChangeListenerReply(listenerRegistration.path()),
+ .tell(new RegisterChangeListenerReply(listenerRegistration.path()).toSerializable(),
getSelf());
}
private void createTransactionChain() {
DOMStoreTransactionChain chain = store.createTransactionChain();
ActorRef transactionChain =
- getContext().actorOf(ShardTransactionChain.props(chain));
+ getContext().actorOf(ShardTransactionChain.props(chain, schemaContext));
getSender()
.tell(new CreateTransactionChainReply(transactionChain.path()),
getSelf());