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