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