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