Switch to Objects.requireNonNull
[mdsal.git] / 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 }