opendaylight/md-sal/sal-netconf-connector/src/main/java/org/opendaylight/controller/sal/connect/netconf/NetconfDeviceTwoPhaseCommitTransaction.java

   1 package org.opendaylight.controller.sal.connect.netconf;
   2
   3 import java.util.Collections;
   4 import java.util.List;
   5 import java.util.Map;
   6 import java.util.Map.Entry;
   7 import java.util.Set;
   8
   9 import org.eclipse.xtext.xbase.lib.IterableExtensions;
  10 import org.opendaylight.controller.md.sal.common.api.data.DataModification;
  11 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction;
  12 import org.opendaylight.yangtools.yang.common.QName;
  13 import org.opendaylight.yangtools.yang.common.RpcResult;
  14 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  15 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
  16 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
  17 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
  18 import org.opendaylight.yangtools.yang.data.api.Node;
  19 import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
  20 import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
  21
  22 import com.google.common.base.Optional;
  23 import com.google.common.base.Preconditions;
  24 import com.google.common.collect.Collections2;
  25 import com.google.common.collect.ImmutableList;
  26 import com.google.common.collect.Iterables;
  27 import com.google.common.collect.Lists;
  28
  29 import static org.opendaylight.controller.sal.connect.netconf.NetconfMapping.*;
  30
  31 public class NetconfDeviceTwoPhaseCommitTransaction implements DataCommitTransaction<InstanceIdentifier, CompositeNode> {
  32
  33     private NetconfDevice device;
  34     private final DataModification<InstanceIdentifier, CompositeNode> modification;
  35     private boolean candidateSupported = true;
  36
  37     public NetconfDeviceTwoPhaseCommitTransaction(NetconfDevice device,
  38             DataModification<InstanceIdentifier, CompositeNode> modification) {
  39         super();
  40         this.device = device;
  41         this.modification = modification;
  42     }
  43
  44     public void prepare() {
  45         for (InstanceIdentifier toRemove : modification.getRemovedConfigurationData()) {
  46             sendRemove(toRemove);
  47         }
  48         for(Entry<InstanceIdentifier, CompositeNode> toUpdate : modification.getUpdatedConfigurationData().entrySet()) {
  49             sendMerge(toUpdate.getKey(),toUpdate.getValue());
  50         }
  51
  52     }
  53
  54     private void sendMerge(InstanceIdentifier key, CompositeNode value) {
  55         sendEditRpc(createEditStructure(key, Optional.<String>absent(), Optional.of(value)));
  56     }
  57
  58     private void sendRemove(InstanceIdentifier toRemove) {
  59         sendEditRpc(createEditStructure(toRemove, Optional.of("remove"), Optional.<CompositeNode> absent()));
  60     }
  61
  62     private void sendEditRpc(CompositeNode editStructure) {
  63         CompositeNodeBuilder<ImmutableCompositeNode> builder = configurationRpcBuilder();
  64         builder.setQName(NETCONF_EDIT_CONFIG_QNAME);
  65         builder.add(editStructure);
  66
  67         RpcResult<CompositeNode> rpcResult = device.invokeRpc(NETCONF_EDIT_CONFIG_QNAME, builder.toInstance());
  68         Preconditions.checkState(rpcResult.isSuccessful(),"Rpc Result was unsuccessful");
  69
  70     }
  71
  72     private CompositeNodeBuilder<ImmutableCompositeNode> configurationRpcBuilder() {
  73         CompositeNodeBuilder<ImmutableCompositeNode> ret = ImmutableCompositeNode.builder();
  74
  75         Node<?> targetNode;
  76         if(candidateSupported) {
  77             targetNode = ImmutableCompositeNode.create(NETCONF_CANDIDATE_QNAME, ImmutableList.<Node<?>>of());
  78         } else {
  79             targetNode = ImmutableCompositeNode.create(NETCONF_RUNNING_QNAME, ImmutableList.<Node<?>>of());
  80         }
  81         Node<?> targetWrapperNode = ImmutableCompositeNode.create(NETCONF_TARGET_QNAME, ImmutableList.<Node<?>>of(targetNode));
  82         ret.add(targetWrapperNode);
  83         return ret;
  84     }
  85
  86     private CompositeNode createEditStructure(InstanceIdentifier dataPath, Optional<String> action,
  87             Optional<CompositeNode> lastChildOverride) {
  88         List<PathArgument> path = dataPath.getPath();
  89         List<PathArgument> reversed = Lists.reverse(path);
  90         CompositeNode previous = null;
  91         boolean isLast = true;
  92         for (PathArgument arg : reversed) {
  93             CompositeNodeBuilder<ImmutableCompositeNode> builder = ImmutableCompositeNode.builder();
  94             builder.setQName(arg.getNodeType());
  95             Map<QName, Object> predicates = Collections.emptyMap();
  96             if (arg instanceof NodeIdentifierWithPredicates) {
  97                 predicates = ((NodeIdentifierWithPredicates) arg).getKeyValues();
  98             }
  99             for (Entry<QName, Object> entry : predicates.entrySet()) {
 100                 builder.addLeaf(entry.getKey(), entry.getValue());
 101             }
 102
 103             if (isLast) {
 104                 if (action.isPresent()) {
 105                     builder.setAttribute(NETCONF_ACTION_QNAME, action.get());
 106                 }
 107                 if (lastChildOverride.isPresent()) {
 108                     List<Node<?>> children = lastChildOverride.get().getChildren();
 109                     for(Node<?> child : children) {
 110                         if(!predicates.containsKey(child.getKey())) {
 111                             builder.add(child);
 112                         }
 113                     }
 114
 115                 }
 116             } else {
 117                 builder.add(previous);
 118             }
 119             previous = builder.toInstance();
 120             isLast = false;
 121         }
 122         return ImmutableCompositeNode.create(NETCONF_CONFIG_QNAME, ImmutableList.<Node<?>>of(previous));
 123     }
 124
 125     @Override
 126     public RpcResult<Void> finish() throws IllegalStateException {
 127         CompositeNodeBuilder<ImmutableCompositeNode> commitInput = ImmutableCompositeNode.builder();
 128         commitInput.setQName(NETCONF_COMMIT_QNAME);
 129         RpcResult<?> rpcResult = device.invokeRpc(NetconfMapping.NETCONF_COMMIT_QNAME, commitInput.toInstance());
 130         return (RpcResult<Void>) rpcResult;
 131     }
 132
 133     @Override
 134     public DataModification<InstanceIdentifier, CompositeNode> getModification() {
 135         return this.modification;
 136     }
 137
 138     @Override
 139     public RpcResult<Void> rollback() throws IllegalStateException {
 140         // TODO Auto-generated method stub
 141         return null;
 142     }
 143 }