binding/mdsal-binding-runtime-spi/src/main/java/org/opendaylight/mdsal/binding/runtime/spi/BindingRuntimeHelpers.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 com.google.common.annotations.Beta;
  11 import com.google.common.base.Throwables;
  12 import java.util.Arrays;
  13 import java.util.Collection;
  14 import java.util.stream.Collectors;
  15 import org.eclipse.jdt.annotation.NonNull;
  16 import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
  17 import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeGenerator;
  18 import org.opendaylight.mdsal.binding.runtime.api.DefaultBindingRuntimeContext;
  19 import org.opendaylight.mdsal.binding.runtime.api.ModuleInfoSnapshot;
  20 import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
  21 import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
  22 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  23 import org.opendaylight.yangtools.yang.parser.api.YangParserException;
  24 import org.opendaylight.yangtools.yang.parser.api.YangParserFactory;
  25
  26 /**
  27  * Simple helpers to help with reconstruction of BindingRuntimeContext from generated binding classes. These involve
  28  * reflection and YANG model assembly, hence should not be used without any caching whatsoever or any support for
  29  * dynamic schema updates.
  30  */
  31 @Beta
  32 public final class BindingRuntimeHelpers {
  33     private BindingRuntimeHelpers() {
  34
  35     }
  36
  37     public static @NonNull EffectiveModelContext createEffectiveModel(final Class<?>... classes) {
  38         return createEffectiveModel(Arrays.stream(classes)
  39             .map(BindingRuntimeHelpers::extractYangModuleInfo)
  40             .collect(Collectors.toList()));
  41     }
  42
  43     public static @NonNull EffectiveModelContext createEffectiveModel(
  44             final Iterable<? extends YangModuleInfo> moduleInfos) {
  45         try {
  46             return createEffectiveModel(ServiceLoaderState.ParserFactory.INSTANCE, moduleInfos);
  47         } catch (YangParserException e) {
  48             throw new IllegalStateException("Failed to parse models", e);
  49         }
  50     }
  51
  52     public static @NonNull EffectiveModelContext createEffectiveModel(final YangParserFactory parserFactory,
  53             final Iterable<? extends YangModuleInfo> moduleInfos) throws YangParserException {
  54         return prepareContext(parserFactory, moduleInfos).getEffectiveModelContext();
  55     }
  56
  57     public static @NonNull BindingRuntimeContext createRuntimeContext() {
  58         final ModuleInfoSnapshot infos;
  59         try {
  60             infos = prepareContext(ServiceLoaderState.ParserFactory.INSTANCE,
  61                 BindingReflections.loadModuleInfos());
  62         } catch (YangParserException e) {
  63             throw new IllegalStateException("Failed to parse models", e);
  64         }
  65         return new DefaultBindingRuntimeContext(ServiceLoaderState.Generator.INSTANCE.generateTypeMapping(
  66             infos.getEffectiveModelContext()), infos);
  67     }
  68
  69     public static @NonNull BindingRuntimeContext createRuntimeContext(final Class<?>... classes) {
  70         try {
  71             return createRuntimeContext(ServiceLoaderState.ParserFactory.INSTANCE,
  72                 ServiceLoaderState.Generator.INSTANCE, classes);
  73         } catch (YangParserException e) {
  74             throw new IllegalStateException("Failed to parse models", e);
  75         }
  76     }
  77
  78     public static @NonNull BindingRuntimeContext createRuntimeContext(
  79             final Collection<? extends YangModuleInfo> infos) {
  80         final ModuleInfoSnapshot snapshot;
  81
  82         try {
  83             snapshot = prepareContext(ServiceLoaderState.ParserFactory.INSTANCE, infos);
  84         } catch (YangParserException e) {
  85             throw new IllegalStateException("Failed to parse models", e);
  86         }
  87
  88         return new DefaultBindingRuntimeContext(
  89             ServiceLoaderState.Generator.INSTANCE.generateTypeMapping(snapshot.getEffectiveModelContext()), snapshot);
  90     }
  91
  92     public static @NonNull BindingRuntimeContext createRuntimeContext(final YangParserFactory parserFactory,
  93             final BindingRuntimeGenerator generator, final Class<?>... classes) throws YangParserException {
  94         return createRuntimeContext(parserFactory, generator, Arrays.asList(classes));
  95     }
  96
  97     public static @NonNull BindingRuntimeContext createRuntimeContext(final YangParserFactory parserFactory,
  98             final BindingRuntimeGenerator generator, final Collection<Class<?>> classes) throws YangParserException {
  99         final ModuleInfoSnapshot infos = prepareContext(parserFactory, classes.stream()
 100             .map(BindingRuntimeHelpers::extractYangModuleInfo)
 101             .collect(Collectors.toList()));
 102         return new DefaultBindingRuntimeContext(generator.generateTypeMapping(infos.getEffectiveModelContext()), infos);
 103     }
 104
 105     @SuppressWarnings("checkstyle:IllegalCatch")
 106     private static @NonNull YangModuleInfo extractYangModuleInfo(final Class<?> clazz) {
 107         try {
 108             return BindingReflections.getModuleInfo(clazz);
 109         } catch (Exception e) {
 110             Throwables.throwIfUnchecked(e);
 111             throw new IllegalStateException("Failed to extract module info from " + clazz, e);
 112         }
 113     }
 114
 115     private static @NonNull ModuleInfoSnapshot prepareContext(final YangParserFactory parserFactory,
 116             final Iterable<? extends YangModuleInfo> moduleInfos) throws YangParserException {
 117         return new ModuleInfoSnapshotBuilder(parserFactory).add(moduleInfos).build();
 118     }
 119 }