opendaylight/md-sal/compatibility/flow-management-compatibility/src/main/java/org/opendaylight/controller/md/frm/compatibility/FRMRuntimeDataProvider.xtend

   1 package org.opendaylight.controller.md.frm.compatibility
   2
   3 import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider
   4 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
   5 import org.opendaylight.yangtools.yang.binding.DataObject
   6 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler
   7 import org.opendaylight.controller.md.sal.common.api.data.DataModification
   8 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction
   9 import org.opendaylight.controller.sal.binding.api.data.DataProviderService
  10 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.FlowKey
  11 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.flows.Flow
  12 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.Flows
  13 import org.opendaylight.controller.md.sal.common.api.data.DataChangeListener
  14 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.config.rev130819.FlowsBuilder
  15 import org.opendaylight.controller.forwardingrulesmanager.IForwardingRulesManager
  16 import static com.google.common.base.Preconditions.*;
  17 import static extension org.opendaylight.controller.md.frm.compatibility.FlowConfigMapping.*;
  18 import static extension org.opendaylight.controller.sal.compatibility.NodeMapping.*;
  19 import org.opendaylight.controller.sal.common.util.Arguments
  20 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem
  21 import org.opendaylight.yangtools.yang.common.RpcResult
  22 import org.opendaylight.controller.forwardingrulesmanager.FlowConfig
  23 import java.util.HashSet
  24 import org.opendaylight.controller.sal.common.util.Rpcs
  25 import java.util.Collections
  26 import org.opendaylight.yangtools.yang.common.RpcError
  27
  28 class FRMRuntimeDataProvider implements RuntimeDataProvider, DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject> {
  29
  30     static val FLOWS_PATH = InstanceIdentifier.builder().node(Flows).toInstance;
  31
  32     @Property
  33     var DataProviderService dataService;
  34
  35     @Property
  36     var DataChangeListener changeListener;
  37
  38     @Property
  39     var IForwardingRulesManager manager;
  40
  41     FlowManagementReader configuration = new ConfigurationReader();
  42
  43     def init() {
  44         //dataService.registerDataChangeListener(FLOWS_PATH, changeListener);
  45         dataService.registerCommitHandler(FLOWS_PATH, this);
  46     }
  47
  48     override readConfigurationData(InstanceIdentifier<? extends DataObject> path) {
  49         return readFrom(configuration, path);
  50     }
  51
  52     override DataObject readOperationalData(InstanceIdentifier<? extends DataObject> path) {
  53         return readFrom(configuration, path);
  54     }
  55
  56     def DataObject readFrom(FlowManagementReader store, InstanceIdentifier<? extends DataObject> path) {
  57         if (FLOWS_PATH == path) {
  58             return store.readAllFlows();
  59         }
  60         if (FLOWS_PATH.contains(path)) {
  61             return store.readFlow(path.toFlowKey());
  62         }
  63         return null;
  64     }
  65
  66     override FlowCommitTransaction requestCommit(
  67         DataModification modification) {
  68         return new FlowCommitTransaction(this,modification);
  69     }
  70
  71     def toFlowKey(InstanceIdentifier<? extends DataObject> identifier) {
  72         checkNotNull(identifier)
  73         val item = Arguments.checkInstanceOf(identifier.path.get(1),IdentifiableItem);
  74         val key = Arguments.checkInstanceOf(item.key,FlowKey)
  75         return key;
  76     }
  77
  78     def RpcResult<Void> finish(FlowCommitTransaction transaction) {
  79         for(flw: transaction.toRemove) {
  80             manager.removeStaticFlow(flw.name,flw.node)
  81         }
  82
  83         for(flw: transaction.toUpdate) {
  84             manager.removeStaticFlow(flw.name,flw.node);
  85             manager.addStaticFlow(flw);
  86         }
  87
  88         return Rpcs.<Void>getRpcResult(true,null,Collections.<RpcError>emptySet())
  89     }
  90
  91     def RpcResult<Void> rollback(FlowCommitTransaction transaction) {
  92         // NOOP: We did not changed any state.
  93     }
  94
  95 }
  96
  97 class ConfigurationReader implements FlowManagementReader {
  98
  99     @Property
 100     var IForwardingRulesManager manager;
 101
 102     override Flows readAllFlows() {
 103         val it = new FlowsBuilder();
 104         flow = manager.staticFlows.map[
 105             toConfigurationFlow();
 106         ]
 107         return it.build();
 108     }
 109
 110     override readFlow(FlowKey key) {
 111         val flowCfg = manager.getStaticFlow(String.valueOf(key.id), key.node.toADNode());
 112         return flowCfg.toConfigurationFlow;
 113     }
 114 }
 115
 116 public static class FlowCommitTransaction implements DataCommitTransaction<InstanceIdentifier<? extends DataObject>, DataObject> {
 117
 118     @Property
 119     val DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification;
 120
 121     @Property
 122     val FRMRuntimeDataProvider flowManager;
 123
 124     @Property
 125     val toAdd = new HashSet<FlowConfig>();
 126
 127     @Property
 128     var Iterable<FlowConfig> toUpdate
 129
 130     @Property
 131     var Iterable<FlowConfig> toRemove
 132
 133
 134     new(FRMRuntimeDataProvider flowManager,DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification) {
 135         super();
 136         _flowManager = flowManager;
 137         _modification = modification;
 138         processModification();
 139     }
 140
 141     override finish() throws IllegalStateException {
 142         return flowManager.finish(this);
 143     }
 144
 145     override rollback() throws IllegalStateException
 146 {
 147         return flowManager.rollback(this);
 148     }
 149
 150     def processModification() {
 151         val updated = modification.updatedConfigurationData.entrySet;
 152
 153         val _toUpdate = updated.filter[key.isFlowPath].map[
 154              return (value as Flow).toFlowConfig
 155         ]
 156         toUpdate = _toUpdate as Iterable<FlowConfig>
 157
 158
 159         val _toRemove = modification.removedConfigurationData.filter[isFlowPath].map[
 160              toFlowConfig
 161         ]
 162         toRemove = _toRemove as Iterable<FlowConfig>
 163
 164     }
 165 }