opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/AbstractTransaction.xtend

   1 package org.opendaylight.controller.frm
   2
   3 import java.util.Collections
   4 import java.util.HashSet
   5 import java.util.Map.Entry
   6 import java.util.Set
   7 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction
   8 import org.opendaylight.controller.md.sal.common.api.data.DataModification
   9 import org.opendaylight.controller.sal.common.util.Rpcs
  10 import org.opendaylight.yangtools.yang.binding.DataObject
  11 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
  12 import org.opendaylight.yangtools.yang.common.RpcError
  13
  14 abstract class AbstractTransaction implements DataCommitTransaction<InstanceIdentifier<?extends DataObject>, DataObject> {
  15
  16     @Property
  17     val DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification;
  18
  19     new(DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification) {
  20         _modification = modification;
  21     }
  22
  23     def void validate() throws IllegalStateException
  24
  25     override finish() throws IllegalStateException {
  26         validate()
  27         callRpcs();
  28         return Rpcs.getRpcResult(true, null, Collections.<RpcError>emptySet());
  29     }
  30
  31     override getModification() {
  32         return _modification;
  33     }
  34
  35     override rollback() throws IllegalStateException {
  36         rollbackRpcs();
  37         return Rpcs.getRpcResult(true, null, Collections.<RpcError>emptySet());
  38     }
  39
  40     def private callRpcs() {
  41         val Set<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> createdEntries = _modification.getCreatedConfigurationData().entrySet();
  42
  43         /*
  44          * This little dance is because updatedEntries contains both created and modified entries
  45          * The reason I created a new HashSet is because the collections we are returned are immutable.
  46          */
  47         val Set<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> updatedEntries = new HashSet<Entry<InstanceIdentifier<? extends DataObject>, DataObject>>();
  48         updatedEntries.addAll(_modification.getUpdatedConfigurationData().entrySet());
  49         updatedEntries.removeAll(createdEntries);
  50
  51         val Set<InstanceIdentifier<? extends DataObject>> removeEntriesInstanceIdentifiers = _modification.getRemovedConfigurationData();
  52         for (Entry<InstanceIdentifier<? extends DataObject >, DataObject> entry : createdEntries) {
  53             add(entry.key,entry.value);
  54         }
  55         for (Entry<InstanceIdentifier<?>, DataObject> entry : updatedEntries) {
  56                 val originalFlow = _modification.originalConfigurationData.get(entry.key);
  57                 val updatedFlow = entry.value
  58                 update(entry.key, originalFlow ,updatedFlow);
  59         }
  60
  61         for (InstanceIdentifier<?> instanceId : removeEntriesInstanceIdentifiers ) {
  62             val removeValue = _modification.getOriginalConfigurationData.get(instanceId);
  63                 remove(instanceId,removeValue);
  64         }
  65     }
  66
  67     def void remove(InstanceIdentifier<?> identifier, DataObject remove)
  68
  69     def void update(InstanceIdentifier<?> identifier, DataObject original, DataObject update)
  70
  71     def void add(InstanceIdentifier<?> identifier, DataObject add)
  72
  73     def private rollbackRpcs() {
  74         val Set<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> createdEntries = _modification.getCreatedConfigurationData().entrySet();
  75
  76         /*
  77          * This little dance is because updatedEntries contains both created and modified entries
  78          * The reason I created a new HashSet is because the collections we are returned are immutable.
  79          */
  80         val Set<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> updatedEntries = new HashSet<Entry<InstanceIdentifier<? extends DataObject>, DataObject>>();
  81         updatedEntries.addAll(_modification.getUpdatedConfigurationData().entrySet());
  82         updatedEntries.removeAll(createdEntries);
  83
  84         val Set<InstanceIdentifier<? >> removeEntriesInstanceIdentifiers = _modification.getRemovedConfigurationData();
  85         for (Entry<InstanceIdentifier<?>, DataObject> entry : createdEntries) {
  86             remove(entry.key,entry.value); // because we are rolling back, remove what we would have added.
  87         }
  88         for (Entry<InstanceIdentifier<?>, DataObject> entry : updatedEntries) {
  89             val originalFlow = _modification.originalConfigurationData.get(entry.key);
  90             val updatedFlow = entry.value
  91             update(entry.key, updatedFlow ,originalFlow);// because we are rolling back, replace the updated with the original
  92         }
  93
  94         for (InstanceIdentifier<?> instanceId : removeEntriesInstanceIdentifiers ) {
  95             val removeValue = _modification.getOriginalConfigurationData.get(instanceId);
  96             add(instanceId,removeValue);// because we are rolling back, add what we would have removed.
  97         }
  98     }
  99 }