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

   1 package org.opendaylight.controller.sal.connect.netconf.listener;
   2
   3 import com.google.common.base.Objects;
   4 import com.google.common.base.Optional;
   5 import com.google.common.base.Preconditions;
   6 import com.google.common.base.Predicate;
   7 import com.google.common.base.Splitter;
   8 import com.google.common.collect.ImmutableSet;
   9 import com.google.common.collect.Iterables;
  10 import com.google.common.collect.Sets;
  11
  12 import java.util.Collection;
  13 import java.util.HashSet;
  14 import java.util.Set;
  15
  16 import org.opendaylight.controller.netconf.client.NetconfClientSession;
  17 import org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.slf4j.Logger;
  20 import org.slf4j.LoggerFactory;
  21
  22 public final class NetconfSessionCapabilities {
  23
  24     private static final class ParameterMatcher {
  25         private final Predicate<String> predicate;
  26         private final int skipLength;
  27
  28         ParameterMatcher(final String name) {
  29             predicate = new Predicate<String>() {
  30                 @Override
  31                 public boolean apply(final String input) {
  32                     return input.startsWith(name);
  33                 }
  34             };
  35
  36             this.skipLength = name.length();
  37         }
  38
  39         private String from(final Iterable<String> params) {
  40             final Optional<String> o = Iterables.tryFind(params, predicate);
  41             if (!o.isPresent()) {
  42                 return null;
  43             }
  44
  45             return o.get().substring(skipLength);
  46         }
  47     }
  48
  49     private static final Logger LOG = LoggerFactory.getLogger(NetconfSessionCapabilities.class);
  50     private static final ParameterMatcher MODULE_PARAM = new ParameterMatcher("module=");
  51     private static final ParameterMatcher REVISION_PARAM = new ParameterMatcher("revision=");
  52     private static final ParameterMatcher BROKEN_REVISON_PARAM = new ParameterMatcher("amp;revision=");
  53     private static final Splitter AMP_SPLITTER = Splitter.on('&');
  54     private static final Predicate<String> CONTAINS_REVISION = new Predicate<String>() {
  55         @Override
  56         public boolean apply(final String input) {
  57             return input.contains("revision=");
  58         }
  59     };
  60
  61     private final Set<QName> moduleBasedCaps;
  62     private final Set<String> nonModuleCaps;
  63
  64     private NetconfSessionCapabilities(final Set<String> nonModuleCaps, final Set<QName> moduleBasedCaps) {
  65         this.nonModuleCaps = Preconditions.checkNotNull(nonModuleCaps);
  66         this.moduleBasedCaps = Preconditions.checkNotNull(moduleBasedCaps);
  67     }
  68
  69     public Set<QName> getModuleBasedCaps() {
  70         return moduleBasedCaps;
  71     }
  72
  73     public Set<String> getNonModuleCaps() {
  74         return nonModuleCaps;
  75     }
  76
  77     public boolean containsNonModuleCapability(final String capability) {
  78         return nonModuleCaps.contains(capability);
  79     }
  80
  81     public boolean containsModuleCapability(final QName capability) {
  82         return moduleBasedCaps.contains(capability);
  83     }
  84
  85     @Override
  86     public String toString() {
  87         return Objects.toStringHelper(this)
  88                 .add("capabilities", nonModuleCaps)
  89                 .add("moduleBasedCapabilities", moduleBasedCaps)
  90                 .add("rollback", isRollbackSupported())
  91                 .add("monitoring", isMonitoringSupported())
  92                 .toString();
  93     }
  94
  95     public boolean isRollbackSupported() {
  96         return containsNonModuleCapability(NetconfMessageTransformUtil.NETCONF_ROLLBACK_ON_ERROR_URI.toString());
  97     }
  98
  99     public boolean isCandidateSupported() {
 100         return containsNonModuleCapability(NetconfMessageTransformUtil.NETCONF_CANDIDATE_URI.toString());
 101     }
 102
 103     public boolean isMonitoringSupported() {
 104         return containsModuleCapability(NetconfMessageTransformUtil.IETF_NETCONF_MONITORING)
 105                 || containsNonModuleCapability(NetconfMessageTransformUtil.IETF_NETCONF_MONITORING.getNamespace().toString());
 106     }
 107
 108     public NetconfSessionCapabilities replaceModuleCaps(final NetconfSessionCapabilities netconfSessionModuleCapabilities) {
 109         final Set<QName> moduleBasedCaps = Sets.newHashSet(netconfSessionModuleCapabilities.getModuleBasedCaps());
 110
 111         // Preserve monitoring module, since it indicates support for ietf-netconf-monitoring
 112         if(containsModuleCapability(NetconfMessageTransformUtil.IETF_NETCONF_MONITORING)) {
 113             moduleBasedCaps.add(NetconfMessageTransformUtil.IETF_NETCONF_MONITORING);
 114         }
 115         return new NetconfSessionCapabilities(getNonModuleCaps(), moduleBasedCaps);
 116     }
 117
 118     public static NetconfSessionCapabilities fromNetconfSession(final NetconfClientSession session) {
 119         return fromStrings(session.getServerCapabilities());
 120     }
 121
 122     private static final QName cachedQName(String namespace, String revision, String moduleName) {
 123         return QName.cachedReference(QName.create(namespace, revision, moduleName));
 124     }
 125
 126     public static NetconfSessionCapabilities fromStrings(final Collection<String> capabilities) {
 127         final Set<QName> moduleBasedCaps = new HashSet<>();
 128         final Set<String> nonModuleCaps = Sets.newHashSet(capabilities);
 129
 130         for (final String capability : capabilities) {
 131             final int qmark = capability.indexOf('?');
 132             if (qmark == -1) {
 133                 continue;
 134             }
 135
 136             final String namespace = capability.substring(0, qmark);
 137             final Iterable<String> queryParams = AMP_SPLITTER.split(capability.substring(qmark + 1));
 138             final String moduleName = MODULE_PARAM.from(queryParams);
 139             if (moduleName == null) {
 140                 continue;
 141             }
 142
 143             String revision = REVISION_PARAM.from(queryParams);
 144             if (revision != null) {
 145                 moduleBasedCaps.add(cachedQName(namespace, revision, moduleName));
 146                 nonModuleCaps.remove(capability);
 147                 continue;
 148             }
 149
 150             /*
 151              * We have seen devices which mis-escape revision, but the revision may not
 152              * even be there. First check if there is a substring that matches revision.
 153              */
 154             if (!Iterables.any(queryParams, CONTAINS_REVISION)) {
 155                 continue;
 156             }
 157
 158             LOG.debug("Netconf device was not reporting revision correctly, trying to get amp;revision=");
 159             revision = BROKEN_REVISON_PARAM.from(queryParams);
 160             if (revision == null) {
 161                 LOG.warn("Netconf device returned revision incorrectly escaped for {}, ignoring it", capability);
 162             }
 163
 164             // FIXME: do we really want to continue here?
 165             moduleBasedCaps.add(cachedQName(namespace, revision, moduleName));
 166             nonModuleCaps.remove(capability);
 167         }
 168
 169         return new NetconfSessionCapabilities(ImmutableSet.copyOf(nonModuleCaps), ImmutableSet.copyOf(moduleBasedCaps));
 170     }
 171 }