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

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