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

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