binding2/mdsal-binding2-maven-api-gen-plugin/src/main/java/org/opendaylight/mdsal/binding/javav2/maven/api/gen/plugin/CodeGeneratorImpl.java

   1 /*
   2  * Copyright (c) 2017 Cisco Systems, Inc. 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
   9 package org.opendaylight.mdsal.binding.javav2.maven.api.gen.plugin;
  10
  11 import static java.util.Objects.requireNonNull;
  12 import static org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer.normalizeFullPackageName;
  13 import static org.opendaylight.mdsal.binding.javav2.util.BindingMapping.getRootPackageName;
  14
  15 import com.google.common.annotations.Beta;
  16 import com.google.common.base.Joiner;
  17 import com.google.common.collect.ImmutableSet;
  18 import com.google.common.collect.ImmutableSet.Builder;
  19 import java.io.BufferedWriter;
  20 import java.io.File;
  21 import java.io.IOException;
  22 import java.io.OutputStream;
  23 import java.io.OutputStreamWriter;
  24 import java.io.Writer;
  25 import java.nio.charset.StandardCharsets;
  26 import java.util.Collection;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Optional;
  30 import java.util.Set;
  31 import java.util.function.Function;
  32 import org.apache.maven.project.MavenProject;
  33 import org.opendaylight.mdsal.binding.javav2.generator.api.BindingGenerator;
  34 import org.opendaylight.mdsal.binding.javav2.generator.impl.BindingGeneratorImpl;
  35 import org.opendaylight.mdsal.binding.javav2.java.api.generator.GeneratorJavaFile;
  36 import org.opendaylight.mdsal.binding.javav2.java.api.generator.renderers.YangModuleInfoTemplateRenderer;
  37 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
  38 import org.opendaylight.mdsal.binding.javav2.spec.runtime.YangModelBindingProvider;
  39 import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
  40 import org.opendaylight.yangtools.yang.model.api.Module;
  41 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  42 import org.opendaylight.yangtools.yang2sources.spi.BasicCodeGenerator;
  43 import org.opendaylight.yangtools.yang2sources.spi.BuildContextAware;
  44 import org.opendaylight.yangtools.yang2sources.spi.MavenProjectAware;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47 import org.sonatype.plexus.build.incremental.BuildContext;
  48
  49 @Beta
  50 public final class CodeGeneratorImpl implements BasicCodeGenerator, BuildContextAware, MavenProjectAware {
  51
  52     private static final Logger LOG = LoggerFactory.getLogger(CodeGeneratorImpl.class);
  53     private static final String FS = File.separator;
  54     private BuildContext buildContext;
  55     private File projectBaseDir;
  56     private Map<String, String> additionalConfig;
  57     private MavenProject mavenProject;
  58     private File resourceBaseDir;
  59
  60     /**
  61      * This method is called from mojo (maven goal)
  62      * @param context
  63      *            parsed from YANG files
  64      * @param outputBaseDir
  65      *            expected output directory for generated sources configured by
  66      *            user
  67      * @param currentModules
  68      *            YANG modules parsed from yangFilesRootDir
  69      * @param moduleResourcePathResolver
  70      *            Function converting a local module to the packaged resource path
  71      * @return
  72      * @throws IOException
  73      */
  74     @Override
  75     public Collection<File> generateSources(SchemaContext context, File outputBaseDir, Set<Module> currentModules, Function<Module, Optional<String>> moduleResourcePathResolver) throws IOException {
  76         final BindingGenerator bindingGenerator = new BindingGeneratorImpl(true);
  77         final List<Type> types = bindingGenerator.generateTypes(context, currentModules);
  78         final GeneratorJavaFile generator = new GeneratorJavaFile(buildContext, types);
  79
  80         File persistentSourcesDir = null;
  81         if (additionalConfig != null) {
  82             String persistentSourcesPath = additionalConfig.get("persistentSourcesDir");
  83             if (persistentSourcesPath != null) {
  84                 persistentSourcesDir = new File(persistentSourcesPath);
  85             }
  86         }
  87         if (persistentSourcesDir == null) {
  88             persistentSourcesDir = new File(projectBaseDir, "src" + FS + "main" + FS + "java");
  89         }
  90
  91         List<File> result = generator.generateToFile(outputBaseDir, persistentSourcesDir);
  92
  93         result.addAll(generateModuleInfos(outputBaseDir, currentModules, context, moduleResourcePathResolver));
  94         return result;
  95     }
  96
  97     @Override
  98     public void setAdditionalConfig(Map<String, String> additionalConfiguration) {
  99         this.additionalConfig = additionalConfiguration;
 100     }
 101
 102     @Override
 103     public void setResourceBaseDir(File resourceBaseDir) {
 104         this.resourceBaseDir = resourceBaseDir;
 105     }
 106
 107     @Override
 108     public void setBuildContext(BuildContext buildContext) {
 109         this.buildContext = requireNonNull(buildContext);
 110     }
 111
 112     @Override
 113     public void setMavenProject(MavenProject project) {
 114         this.mavenProject = project;
 115         this.projectBaseDir = project.getBasedir();
 116     }
 117
 118     private Collection<? extends File> generateModuleInfos(final File outputBaseDir, final Set<Module> yangModules,
 119                                                            final SchemaContext context, final Function<Module, Optional<String>> moduleResourcePathResolver) {
 120         Builder<File> result = ImmutableSet.builder();
 121         Builder<String> bindingProviders = ImmutableSet.builder();
 122         for (Module module : yangModules) {
 123             Builder<String> currentProvidersBuilder = ImmutableSet.builder();
 124             Set<File> moduleInfoProviders = generateYangModuleInfo(outputBaseDir, module, context,
 125                     moduleResourcePathResolver, currentProvidersBuilder);
 126             ImmutableSet<String> currentProviders = currentProvidersBuilder.build();
 127             LOG.info("Adding ModuleInfo providers {}", currentProviders);
 128             bindingProviders.addAll(currentProviders);
 129             result.addAll(moduleInfoProviders);
 130         }
 131
 132         result.add(writeMetaInfServices(resourceBaseDir, YangModelBindingProvider.class, bindingProviders.build()));
 133         return result.build();
 134     }
 135
 136     private File writeMetaInfServices(final File outputBaseDir, final Class<YangModelBindingProvider> serviceClass,
 137                                       final ImmutableSet<String> services) {
 138         File metainfServicesFolder = new File(outputBaseDir, "META-INF" + File.separator + "services");
 139         metainfServicesFolder.mkdirs();
 140         File serviceFile = new File(metainfServicesFolder, serviceClass.getName());
 141
 142         String src = Joiner.on('\n').join(services);
 143
 144         return writeFile(serviceFile, src);
 145     }
 146
 147     private Set<File> generateYangModuleInfo(final File outputBaseDir, final Module module, final SchemaContext ctx,
 148            final Function<Module, Optional<String>> moduleResourcePathResolver, final Builder<String> providerSourceSet) {
 149
 150         Builder<File> generatedFiles = ImmutableSet.builder();
 151         final YangModuleInfoTemplateRenderer template = new YangModuleInfoTemplateRenderer(module, ctx,
 152                 moduleResourcePathResolver);
 153         String moduleInfoSource = template.generateTemplate();
 154         if (moduleInfoSource.isEmpty()) {
 155             throw new IllegalStateException("Generated code should not be empty!");
 156         }
 157         String providerSource = template.generateModelProvider();
 158
 159         final File packageDir = GeneratorJavaFile.packageToDirectory(outputBaseDir,
 160                 normalizeFullPackageName(getRootPackageName(module)));
 161
 162         generatedFiles.add(writeJavaSource(packageDir, BindingMapping.MODULE_INFO_CLASS_NAME, moduleInfoSource));
 163         generatedFiles
 164                 .add(writeJavaSource(packageDir, BindingMapping.MODEL_BINDING_PROVIDER_CLASS_NAME, providerSource));
 165         providerSourceSet.add(template.getModelBindingProviderName());
 166
 167         return generatedFiles.build();
 168
 169     }
 170
 171     private File writeFile(final File file, final String source) {
 172         try (final OutputStream stream = buildContext.newFileOutputStream(file)) {
 173             try (final Writer fw = new OutputStreamWriter(stream, StandardCharsets.UTF_8)) {
 174                 try (final BufferedWriter bw = new BufferedWriter(fw)) {
 175                     bw.write(source);
 176                 }
 177             } catch (Exception e) {
 178                 LOG.error("Could not write file: {}",file,e);
 179             }
 180         } catch (Exception e) {
 181             LOG.error("Could not create file: {}",file,e);
 182         }
 183         return file;
 184     }
 185
 186     private File writeJavaSource(final File packageDir, final String className, final String source) {
 187         if (!packageDir.exists()) {
 188             packageDir.mkdirs();
 189         }
 190         final File file = new File(packageDir, className + ".java");
 191         writeFile(file, source);
 192         return file;
 193     }
 194 }