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