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

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