yanglib/mdsal-yanglib-rfc8525/src/main/java/org/opendaylight/mdsal/yanglib/rfc8525/MountPointContextFactoryImpl.java

   1 /*
   2  * Copyright (c) 2019 PANTHEON.tech s.r.o. 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.mdsal.yanglib.rfc8525;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static com.google.common.base.Verify.verifyNotNull;
  12 import static java.util.Objects.requireNonNull;
  13
  14 import java.net.MalformedURLException;
  15 import java.net.URL;
  16 import java.util.ArrayList;
  17 import java.util.HashSet;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Optional;
  21 import java.util.Set;
  22 import org.eclipse.jdt.annotation.NonNull;
  23 import org.eclipse.jdt.annotation.Nullable;
  24 import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode;
  25 import org.opendaylight.mdsal.binding.dom.codec.api.BindingIdentityCodec;
  26 import org.opendaylight.mdsal.yanglib.api.SchemaContextResolver;
  27 import org.opendaylight.mdsal.yanglib.api.SourceReference;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.datastores.rev180214.Operational;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.LegacyRevisionUtils;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.ModulesState;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.RevisionIdentifier;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.RevisionUtils;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.YangLibrary;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.module.list.CommonLeafs;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.module.list.Module.ConformanceType;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.yang.library.parameters.Datastore;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.yang.library.parameters.DatastoreKey;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.yang.library.parameters.ModuleSet;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev190104.yang.library.parameters.SchemaKey;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.YangIdentifier;
  42 import org.opendaylight.yangtools.yang.common.MountPointLabel;
  43 import org.opendaylight.yangtools.yang.common.QName;
  44 import org.opendaylight.yangtools.yang.common.Revision;
  45 import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
  46 import org.opendaylight.yangtools.yang.common.XMLNamespace;
  47 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  48 import org.opendaylight.yangtools.yang.data.api.schema.MountPointContextFactory;
  49 import org.opendaylight.yangtools.yang.data.api.schema.MountPointException;
  50 import org.opendaylight.yangtools.yang.data.util.AbstractMountPointContextFactory;
  51 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  52 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
  53 import org.opendaylight.yangtools.yang.parser.api.YangParserException;
  54 import org.slf4j.Logger;
  55 import org.slf4j.LoggerFactory;
  56
  57 final class MountPointContextFactoryImpl extends AbstractMountPointContextFactory {
  58     private static final Logger LOG = LoggerFactory.getLogger(MountPointContextFactoryImpl.class);
  59
  60     @SuppressWarnings("deprecation")
  61     private final BindingDataObjectCodecTreeNode<ModulesState> legacyCodec;
  62     private final BindingDataObjectCodecTreeNode<YangLibrary> codec;
  63     private final BindingIdentityCodec identityCodec;
  64     private final EffectiveModelContext yangLibContext;
  65     private final SchemaContextResolver resolver;
  66
  67     MountPointContextFactoryImpl(final MountPointLabel label, final SchemaContextResolver resolver,
  68             final EffectiveModelContext yangLibContext,
  69             final BindingIdentityCodec identityCodec,
  70             final BindingDataObjectCodecTreeNode<YangLibrary> codec,
  71             @SuppressWarnings("deprecation")
  72             final BindingDataObjectCodecTreeNode<ModulesState> legacyCodec) {
  73         super(label);
  74         this.resolver = requireNonNull(resolver);
  75         this.identityCodec = requireNonNull(identityCodec);
  76         this.yangLibContext = requireNonNull(yangLibContext);
  77         this.codec = requireNonNull(codec);
  78         this.legacyCodec = requireNonNull(legacyCodec);
  79     }
  80
  81     @Override
  82     protected MountPointContextFactory createContextFactory(final MountPointDefinition mountPoint) {
  83         return new MountPointContextFactoryImpl(mountPoint.label(), resolver, yangLibContext, identityCodec, codec,
  84             legacyCodec);
  85     }
  86
  87     @Override
  88     protected Optional<EffectiveModelContext> findSchemaForLibrary(final ContainerName containerName) {
  89         return switch (containerName) {
  90             case RFC7895, RFC8525 -> Optional.of(yangLibContext);
  91         };
  92     }
  93
  94     @Override
  95     protected EffectiveModelContext bindLibrary(final ContainerName containerName, final ContainerNode libData)
  96             throws MountPointException {
  97         return switch (containerName) {
  98             case RFC7895 -> bindLibrary(verifyNotNull(legacyCodec.deserialize(libData)));
  99             case RFC8525 -> bindLibrary(verifyNotNull(codec.deserialize(libData)));
 100         };
 101     }
 102
 103     private @NonNull EffectiveModelContext bindLibrary(final @NonNull YangLibrary yangLib) throws MountPointException {
 104         final var datastores = yangLib.nonnullDatastore();
 105         checkArgument(!datastores.isEmpty(), "No datastore defined");
 106
 107         final var requiredSources = new ArrayList<SourceReference>();
 108         final var librarySources = new ArrayList<SourceReference>();
 109         final var supportedFeatures = new HashSet<QName>();
 110         final var moduleSet = findModuleSet(yangLib, findSchemaName(datastores, Operational.QNAME));
 111         for (var modSet : yangLib.nonnullModuleSet().values()) {
 112             if (moduleSet.remove(modSet.getName())) {
 113                 fillModules(librarySources, requiredSources, supportedFeatures, modSet);
 114             }
 115         }
 116         checkArgument(moduleSet.isEmpty(), "Failed to resolve module sets %s", moduleSet);
 117
 118         try {
 119             return resolver.resolveSchemaContext(librarySources, requiredSources, supportedFeatures);
 120         } catch (YangParserException e) {
 121             throw new MountPointException("Failed to assemble model context", e);
 122         }
 123     }
 124
 125     @SuppressWarnings("deprecation")
 126     private @NonNull EffectiveModelContext bindLibrary(final @NonNull ModulesState modState)
 127             throws MountPointException {
 128         final var requiredSources = new ArrayList<SourceReference>();
 129         final var librarySources = new ArrayList<SourceReference>();
 130         final var supportedFeatures = new HashSet<QName>();
 131
 132         for (var module : modState.nonnullModule().values()) {
 133             final var modRef = sourceRefFor(module, module.getSchema());
 134
 135             final var namespace = XMLNamespace.of(module.requireNamespace().getValue());
 136             for (var feature : module.requireFeature()) {
 137                 supportedFeatures.add(QName.create(namespace, feature.getValue()).intern());
 138             }
 139
 140             // TODO: take deviations into account
 141
 142             if (ConformanceType.Import == module.getConformanceType()) {
 143                 librarySources.add(modRef);
 144             } else {
 145                 requiredSources.add(modRef);
 146             }
 147
 148             for (var submodule : module.nonnullSubmodule().values()) {
 149                 // Submodules go to library, as they are pulled in as needed
 150                 librarySources.add(sourceRefFor(submodule, submodule.getSchema()));
 151             }
 152         }
 153
 154         try {
 155             return resolver.resolveSchemaContext(librarySources, requiredSources, supportedFeatures);
 156         } catch (YangParserException e) {
 157             throw new MountPointException("Failed to assemble model context", e);
 158         }
 159     }
 160
 161     private String findSchemaName(final Map<DatastoreKey, Datastore> datastores, final QName qname) {
 162         final var it = datastores.values().iterator();
 163         final var ds = it.next();
 164
 165         // FIXME: This is ugly, but it is the most compatible thing we can do without knowing the exact requested
 166         //        datastore
 167         if (it.hasNext() && !qname.equals(identityCodec.fromBinding(ds.getName()))) {
 168             do {
 169                 final Datastore next = it.next();
 170                 if (qname.equals(identityCodec.fromBinding(ds.getName()))) {
 171                     return next.getSchema();
 172                 }
 173             } while (it.hasNext());
 174         }
 175
 176         return ds.getSchema();
 177     }
 178
 179     @SuppressWarnings("deprecation")
 180     private static SourceReference sourceRefFor(final CommonLeafs obj, final Uri uri) {
 181         final var sourceId = new SourceIdentifier(Unqualified.of(obj.getName().getValue()),
 182             LegacyRevisionUtils.toYangCommon(obj.getRevision()).orElse(null));
 183         if (uri != null) {
 184             try {
 185                 return SourceReference.of(sourceId, new URL(uri.getValue()));
 186             } catch (MalformedURLException e) {
 187                 LOG.debug("Ignoring invalid schema location {}", uri, e);
 188             }
 189         }
 190
 191         return SourceReference.of(sourceId);
 192     }
 193
 194     private static HashSet<String> findModuleSet(final YangLibrary yangLib, final String schemaName) {
 195         final var schema = yangLib.nonnullSchema().get(new SchemaKey(schemaName));
 196         if (schema == null) {
 197             throw new IllegalArgumentException("Failed to find moduleSet for " + schemaName);
 198         }
 199         return new HashSet<>(schema.getModuleSet());
 200     }
 201
 202     private static void fillModules(final List<SourceReference> librarySources,
 203             final List<SourceReference> requiredSources, final Set<QName> supportedFeatures, final ModuleSet modSet) {
 204         // TODO: take deviations/features into account
 205
 206         for (var mod : modSet.nonnullImportOnlyModule().values()) {
 207             fillSource(librarySources, mod.getName(), RevisionUtils.toYangCommon(mod.getRevision()),
 208                 mod.getLocation());
 209             mod.nonnullSubmodule().values().forEach(sub -> {
 210                 fillSource(librarySources, sub.getName(), toYangCommon(sub.getRevision()), sub.getLocation());
 211             });
 212         }
 213         for (var mod : modSet.nonnullModule().values()) {
 214             fillSource(requiredSources, mod.getName(), toYangCommon(mod.getRevision()), mod.getLocation());
 215             final var namespace = XMLNamespace.of(mod.requireNamespace().getValue());
 216             mod.requireFeature().forEach(feature -> supportedFeatures.add(QName.create(namespace, feature.getValue())));
 217             mod.nonnullSubmodule().values().forEach(sub -> {
 218                 fillSource(librarySources, sub.getName(), toYangCommon(sub.getRevision()), sub.getLocation());
 219             });
 220         }
 221     }
 222
 223     private static void fillSource(final List<SourceReference> sources, final YangIdentifier sourceName,
 224             final Optional<Revision> revision, final Set<Uri> uris) {
 225         final var sourceId = new SourceIdentifier(Unqualified.of(sourceName.getValue()), revision.orElse(null));
 226         final SourceReference sourceRef;
 227         if (uris != null && uris.isEmpty()) {
 228             final var locations = new ArrayList<URL>();
 229             for (Uri uri : uris) {
 230                 try {
 231                     locations.add(new URL(uri.getValue()));
 232                 } catch (MalformedURLException e) {
 233                     LOG.debug("Ignoring invalid schema location {}", uri, e);
 234                 }
 235             }
 236             sourceRef = SourceReference.of(sourceId, locations);
 237         } else {
 238             sourceRef = SourceReference.of(sourceId);
 239         }
 240
 241         sources.add(sourceRef);
 242     }
 243
 244     private static Optional<Revision> toYangCommon(final @Nullable RevisionIdentifier revisionIdentifier) {
 245         return revisionIdentifier == null ? Optional.empty() : Optional.of(Revision.of(revisionIdentifier.getValue()));
 246     }
 247 }