netconf/sal-netconf-connector/src/main/java/org/opendaylight/netconf/sal/connect/netconf/listener/NetconfSessionPreferences.java

   1 /*
   2  * Copyright (c) 2015 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
   9 package org.opendaylight.netconf.sal.connect.netconf.listener;
  10
  11 import com.google.common.base.MoreObjects;
  12 import com.google.common.base.Optional;
  13 import com.google.common.base.Preconditions;
  14 import com.google.common.base.Predicate;
  15 import com.google.common.base.Splitter;
  16 import com.google.common.base.Strings;
  17 import com.google.common.collect.ImmutableSet;
  18 import com.google.common.collect.Iterables;
  19 import com.google.common.collect.Sets;
  20 import java.net.URI;
  21 import java.util.Collection;
  22 import java.util.HashSet;
  23 import java.util.Iterator;
  24 import java.util.Set;
  25 import org.opendaylight.netconf.client.NetconfClientSession;
  26 import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
  27 import org.opendaylight.yangtools.yang.common.QName;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 public final class NetconfSessionPreferences {
  32
  33     private static final class ParameterMatcher {
  34         private final Predicate<String> predicate;
  35         private final int skipLength;
  36
  37         ParameterMatcher(final String name) {
  38             predicate = new Predicate<String>() {
  39                 @Override
  40                 public boolean apply(final String input) {
  41                     return input.startsWith(name);
  42                 }
  43             };
  44
  45             this.skipLength = name.length();
  46         }
  47
  48         private String from(final Iterable<String> params) {
  49             final Optional<String> o = Iterables.tryFind(params, predicate);
  50             if (!o.isPresent()) {
  51                 return null;
  52             }
  53
  54             return o.get().substring(skipLength);
  55         }
  56     }
  57
  58     private static final Logger LOG = LoggerFactory.getLogger(NetconfSessionPreferences.class);
  59     private static final ParameterMatcher MODULE_PARAM = new ParameterMatcher("module=");
  60     private static final ParameterMatcher REVISION_PARAM = new ParameterMatcher("revision=");
  61     private static final ParameterMatcher BROKEN_REVISON_PARAM = new ParameterMatcher("amp;revision=");
  62     private static final Splitter AMP_SPLITTER = Splitter.on('&');
  63     private static final Predicate<String> CONTAINS_REVISION = new Predicate<String>() {
  64         @Override
  65         public boolean apply(final String input) {
  66             return input.contains("revision=");
  67         }
  68     };
  69
  70     private final Set<QName> moduleBasedCaps;
  71     private final Set<String> nonModuleCaps;
  72
  73     NetconfSessionPreferences(final Set<String> nonModuleCaps, final Set<QName> moduleBasedCaps) {
  74         this.nonModuleCaps = Preconditions.checkNotNull(nonModuleCaps);
  75         this.moduleBasedCaps = Preconditions.checkNotNull(moduleBasedCaps);
  76     }
  77
  78     public Set<QName> getModuleBasedCaps() {
  79         return moduleBasedCaps;
  80     }
  81
  82     public Set<String> getNonModuleCaps() {
  83         return nonModuleCaps;
  84     }
  85
  86     // allows partial matches - assuming parameters are in the same order
  87     public boolean containsPartialNonModuleCapability(final String capability) {
  88         final Iterator<String> iterator = nonModuleCaps.iterator();
  89         while(iterator.hasNext()) {
  90             if (iterator.next().startsWith(capability)) {
  91                 LOG.trace("capability {} partially matches {}", capability, nonModuleCaps);
  92                 return true;
  93             }
  94         }
  95         return false;
  96     }
  97
  98     public boolean containsNonModuleCapability(final String capability) {
  99         return nonModuleCaps.contains(capability);
 100     }
 101
 102     public boolean containsModuleCapability(final QName capability) {
 103         return moduleBasedCaps.contains(capability);
 104     }
 105
 106     @Override
 107     public String toString() {
 108         return MoreObjects.toStringHelper(this)
 109                 .add("capabilities", nonModuleCaps)
 110                 .add("moduleBasedCapabilities", moduleBasedCaps)
 111                 .add("rollback", isRollbackSupported())
 112                 .add("monitoring", isMonitoringSupported())
 113                 .add("candidate", isCandidateSupported())
 114                 .add("writableRunning", isRunningWritable())
 115                 .toString();
 116     }
 117
 118     public boolean isRollbackSupported() {
 119         return containsNonModuleCapability(NetconfMessageTransformUtil.NETCONF_ROLLBACK_ON_ERROR_URI.toString());
 120     }
 121
 122     public boolean isCandidateSupported() {
 123         return containsNonModuleCapability(NetconfMessageTransformUtil.NETCONF_CANDIDATE_URI.toString());
 124     }
 125
 126     public boolean isRunningWritable() {
 127         return containsNonModuleCapability(NetconfMessageTransformUtil.NETCONF_RUNNING_WRITABLE_URI.toString());
 128     }
 129
 130     public boolean isNotificationsSupported() {
 131         return containsPartialNonModuleCapability(NetconfMessageTransformUtil.NETCONF_NOTIFICATONS_URI.toString())
 132                 || containsModuleCapability(NetconfMessageTransformUtil.IETF_NETCONF_NOTIFICATIONS);
 133     }
 134
 135     public boolean isMonitoringSupported() {
 136         return containsModuleCapability(NetconfMessageTransformUtil.IETF_NETCONF_MONITORING)
 137                 || containsPartialNonModuleCapability(NetconfMessageTransformUtil.IETF_NETCONF_MONITORING.getNamespace().toString());
 138     }
 139
 140     /**
 141      * Merge module-based list of capabilities with current list of module-based capabilities
 142      *
 143      * @param netconfSessionModuleCapabilities capabilities to merge into this
 144      *
 145      * @return new instance of preferences with merged module-based capabilities
 146      */
 147     public NetconfSessionPreferences addModuleCaps(final NetconfSessionPreferences netconfSessionModuleCapabilities) {
 148         final HashSet<QName> mergedCaps = Sets.newHashSetWithExpectedSize(moduleBasedCaps.size() + netconfSessionModuleCapabilities.getModuleBasedCaps().size());
 149         mergedCaps.addAll(moduleBasedCaps);
 150         mergedCaps.addAll(netconfSessionModuleCapabilities.getModuleBasedCaps());
 151         return new NetconfSessionPreferences(getNonModuleCaps(), mergedCaps);
 152     }
 153
 154     /**
 155      * Override current list of module-based capabilities
 156      *
 157      * @param netconfSessionPreferences capabilities to override in this
 158      *
 159      * @return new instance of preferences with replaced module-based capabilities
 160      */
 161     public NetconfSessionPreferences replaceModuleCaps(final NetconfSessionPreferences netconfSessionPreferences) {
 162         return new NetconfSessionPreferences(getNonModuleCaps(), netconfSessionPreferences.getModuleBasedCaps());
 163     }
 164
 165     public static NetconfSessionPreferences fromNetconfSession(final NetconfClientSession session) {
 166         return fromStrings(session.getServerCapabilities());
 167     }
 168
 169     private static QName cachedQName(final String namespace, final String revision, final String moduleName) {
 170         return QName.create(namespace, revision, moduleName).intern();
 171     }
 172
 173     private static QName cachedQName(final String namespace, final String moduleName) {
 174         return QName.create(URI.create(namespace), null, moduleName).withoutRevision().intern();
 175     }
 176
 177     public static NetconfSessionPreferences fromStrings(final Collection<String> capabilities) {
 178         final Set<QName> moduleBasedCaps = new HashSet<>();
 179         final Set<String> nonModuleCaps = Sets.newHashSet(capabilities);
 180
 181         for (final String capability : capabilities) {
 182             final int qmark = capability.indexOf('?');
 183             if (qmark == -1) {
 184                 continue;
 185             }
 186
 187             final String namespace = capability.substring(0, qmark);
 188             final Iterable<String> queryParams = AMP_SPLITTER.split(capability.substring(qmark + 1));
 189             final String moduleName = MODULE_PARAM.from(queryParams);
 190             if (Strings.isNullOrEmpty(moduleName)) {
 191                 continue;
 192             }
 193
 194             String revision = REVISION_PARAM.from(queryParams);
 195             if (!Strings.isNullOrEmpty(revision)) {
 196                 addModuleQName(moduleBasedCaps, nonModuleCaps, capability, cachedQName(namespace, revision, moduleName));
 197                 continue;
 198             }
 199
 200             /*
 201              * We have seen devices which mis-escape revision, but the revision may not
 202              * even be there. First check if there is a substring that matches revision.
 203              */
 204             if (Iterables.any(queryParams, CONTAINS_REVISION)) {
 205
 206                 LOG.debug("Netconf device was not reporting revision correctly, trying to get amp;revision=");
 207                 revision = BROKEN_REVISON_PARAM.from(queryParams);
 208                 if (Strings.isNullOrEmpty(revision)) {
 209                     LOG.warn("Netconf device returned revision incorrectly escaped for {}, ignoring it", capability);
 210                     addModuleQName(moduleBasedCaps, nonModuleCaps, capability, cachedQName(namespace, moduleName));
 211                 } else {
 212                     addModuleQName(moduleBasedCaps, nonModuleCaps, capability, cachedQName(namespace, revision, moduleName));
 213                 }
 214                 continue;
 215             }
 216
 217             // Fallback, no revision provided for module
 218             addModuleQName(moduleBasedCaps, nonModuleCaps, capability, cachedQName(namespace, moduleName));
 219         }
 220
 221         return new NetconfSessionPreferences(ImmutableSet.copyOf(nonModuleCaps), ImmutableSet.copyOf(moduleBasedCaps));
 222     }
 223
 224
 225     private static void addModuleQName(final Set<QName> moduleBasedCaps, final Set<String> nonModuleCaps, final String capability, final QName qName) {
 226         moduleBasedCaps.add(qName);
 227         nonModuleCaps.remove(capability);
 228     }
 229
 230     private NetconfDeviceCapabilities capabilities = new NetconfDeviceCapabilities();
 231
 232     public NetconfDeviceCapabilities getNetconfDeviceCapabilities() {
 233         return capabilities;
 234     }
 235
 236
 237 }