binding/mdsal-binding-runtime-spi/src/main/java/org/opendaylight/mdsal/binding/runtime/spi/ModuleInfoSnapshotBuilder.java

   1 /*
   2  * Copyright (c) 2020 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.binding.runtime.spi;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.annotations.Beta;
  13 import com.google.common.base.Throwables;
  14 import com.google.common.collect.HashMultimap;
  15 import com.google.common.collect.ImmutableList;
  16 import com.google.common.collect.ImmutableSet;
  17 import com.google.common.collect.Multimaps;
  18 import com.google.common.collect.SetMultimap;
  19 import java.io.IOException;
  20 import java.util.HashMap;
  21 import java.util.HashSet;
  22 import java.util.Set;
  23 import org.eclipse.jdt.annotation.NonNull;
  24 import org.opendaylight.mdsal.binding.runtime.api.ModuleInfoSnapshot;
  25 import org.opendaylight.yangtools.yang.binding.BindingObject;
  26 import org.opendaylight.yangtools.yang.binding.DataRoot;
  27 import org.opendaylight.yangtools.yang.binding.YangFeature;
  28 import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
  29 import org.opendaylight.yangtools.yang.binding.contract.Naming;
  30 import org.opendaylight.yangtools.yang.common.QName;
  31 import org.opendaylight.yangtools.yang.common.QNameModule;
  32 import org.opendaylight.yangtools.yang.model.api.stmt.FeatureSet;
  33 import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
  34 import org.opendaylight.yangtools.yang.parser.api.YangParser;
  35 import org.opendaylight.yangtools.yang.parser.api.YangParserException;
  36 import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
  37 import org.opendaylight.yangtools.yang.parser.api.YangSyntaxErrorException;
  38
  39 @Beta
  40 public final class ModuleInfoSnapshotBuilder {
  41     private final SetMultimap<Class<? extends DataRoot>, YangFeature<?, ?>> moduleFeatures = HashMultimap.create();
  42     private final Set<YangModuleInfo> moduleInfos = new HashSet<>();
  43     private final YangParserFactory parserFactory;
  44
  45     public ModuleInfoSnapshotBuilder(final YangParserFactory parserFactory) {
  46         this.parserFactory = requireNonNull(parserFactory);
  47     }
  48
  49     @SuppressWarnings("checkstyle:illegalCatch")
  50     public @NonNull ModuleInfoSnapshotBuilder add(final Class<? extends BindingObject> clazz) {
  51         final YangModuleInfo moduleInfo;
  52         try {
  53             moduleInfo = BindingRuntimeHelpers.getYangModuleInfo(clazz);
  54         } catch (Exception e) {
  55             Throwables.throwIfUnchecked(e);
  56             throw new IllegalStateException("Failed to introspect " + clazz, e);
  57         }
  58
  59         return add(moduleInfo);
  60     }
  61
  62     @SafeVarargs
  63     public final @NonNull ModuleInfoSnapshotBuilder add(final Class<? extends BindingObject>... classes) {
  64         for (var clazz : classes) {
  65             add(clazz);
  66         }
  67         return this;
  68     }
  69
  70     public @NonNull ModuleInfoSnapshotBuilder add(final YangModuleInfo info) {
  71         ModuleInfoSnapshotResolver.flatDependencies(moduleInfos, info);
  72         return this;
  73     }
  74
  75     public @NonNull ModuleInfoSnapshotBuilder add(final YangModuleInfo... infos) {
  76         for (var info : infos) {
  77             add(info);
  78         }
  79         return this;
  80     }
  81
  82     public @NonNull ModuleInfoSnapshotBuilder add(final Iterable<? extends YangModuleInfo> infos) {
  83         for (YangModuleInfo info : infos) {
  84             add(info);
  85         }
  86         return this;
  87     }
  88
  89     public <R extends @NonNull DataRoot> @NonNull ModuleInfoSnapshotBuilder addModuleFeatures(final Class<R> module,
  90             final Set<? extends YangFeature<?, R>> supportedFeatures) {
  91         moduleFeatures.putAll(requireNonNull(module), ImmutableList.copyOf(supportedFeatures));
  92         return this;
  93     }
  94
  95     /**
  96      * Build {@link ModuleInfoSnapshot} from all {@code moduleInfos} in this builder.
  97      *
  98      * @return Resulting {@link ModuleInfoSnapshot}
  99      * @throws YangParserException if parsing any of the {@link YangModuleInfo} instances fails
 100      */
 101     public @NonNull ModuleInfoSnapshot build() throws YangParserException {
 102         final YangParser parser = parserFactory.createParser();
 103
 104         final var mappedInfos = new HashMap<SourceIdentifier, YangModuleInfo>();
 105         final var classLoaders = new HashMap<String, ClassLoader>();
 106         final var namespaces = new HashMap<String, QNameModule>();
 107
 108         for (var info : moduleInfos) {
 109             final var source = ModuleInfoSnapshotResolver.toYangTextSource(info);
 110             mappedInfos.put(source.getIdentifier(), info);
 111
 112             final Class<?> infoClass = info.getClass();
 113             final String infoRoot = Naming.getModelRootPackageName(infoClass.getPackage().getName());
 114             classLoaders.put(infoRoot, infoClass.getClassLoader());
 115             namespaces.put(infoRoot, info.getName().getModule());
 116
 117             try {
 118                 parser.addSource(source);
 119             } catch (YangSyntaxErrorException | IOException e) {
 120                 throw new YangParserException("Failed to add source for " + info, e);
 121             }
 122         }
 123
 124         if (!moduleFeatures.isEmpty()) {
 125             final var featuresByModule = FeatureSet.builder();
 126             for (var entry : Multimaps.asMap(moduleFeatures).entrySet()) {
 127                 final var moduleData = entry.getKey();
 128                 final var moduleRoot = Naming.getModelRootPackageName(moduleData.getPackage().getName());
 129                 final var moduleNamespace = namespaces.get(moduleRoot);
 130                 if (moduleNamespace == null) {
 131                     throw new YangParserException("Failed to resolve namespace of " + moduleData);
 132                 }
 133
 134                 featuresByModule.addModuleFeatures(moduleNamespace, entry.getValue().stream()
 135                     .map(YangFeature::qname)
 136                     .map(QName::getLocalName)
 137                     .sorted()
 138                     .collect(ImmutableSet.toImmutableSet()));
 139             }
 140             parser.setSupportedFeatures(featuresByModule.build());
 141         }
 142
 143         return new DefaultModuleInfoSnapshot(parser.buildEffectiveModel(), mappedInfos, classLoaders);
 144     }
 145 }