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