/*******************************************************************************
* (c) Copyright 2016 Hewlett-Packard Development Company, L.P.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Apache License v2.0 which accompany this distribution.
*
* The Apache License is available at
* http://www.apache.org/licenses/LICENSE-2.0
*
*******************************************************************************/
package io.cloudslang.maven.compiler;
import io.cloudslang.lang.compiler.SlangCompiler;
import io.cloudslang.lang.compiler.SlangSource;
import io.cloudslang.lang.compiler.configuration.SlangCompilerSpringConfig;
import io.cloudslang.lang.compiler.modeller.model.Executable;
import io.cloudslang.lang.compiler.modeller.result.ExecutableModellingResult;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.io.IOUtils;
import org.codehaus.plexus.compiler.AbstractCompiler;
import org.codehaus.plexus.compiler.CompilerConfiguration;
import org.codehaus.plexus.compiler.CompilerException;
import org.codehaus.plexus.compiler.CompilerMessage;
import org.codehaus.plexus.compiler.CompilerOutputStyle;
import org.codehaus.plexus.compiler.CompilerResult;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.util.DirectoryScanner;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import static java.util.Collections.emptySet;
/**
* Created by hanael on 10/07/2016.
*/
@Component(role = org.codehaus.plexus.compiler.Compiler.class, hint = "cloudslang")
public class CloudSlangMavenCompiler extends AbstractCompiler {
private static String IGNORE_DEPENDENCIES = "ignore-dependencies";
private static String IGNORE_ERRORS = "ignore-errors";
private SlangCompiler slangCompiler;
private boolean compileWithDependencies;
private CompilerMessage.Kind errorLevel;
public CloudSlangMavenCompiler() {
super(CompilerOutputStyle.ONE_OUTPUT_FILE_FOR_ALL_INPUT_FILES, null, null, null);
ApplicationContext ctx = new AnnotationConfigApplicationContext(SlangCompilerSpringConfig.class);
slangCompiler = ctx.getBean(SlangCompiler.class);
}
@Override
public boolean canUpdateTarget(CompilerConfiguration configuration) throws CompilerException {
return false;
}
@Override
public CompilerResult performCompile(CompilerConfiguration config) throws CompilerException {
init(config);
CompilerResult compilerResult = new CompilerResult();
List<CompilerMessage> compilerMessage = new ArrayList<>();
//we do not want the source files that were calculated because we have multiple suffix
//and the framework support only one via the inputFileEnding
config.setSourceFiles(null);
String[] sourceFiles = getSourceFiles(config);
Map<String, byte[]> dependenciesSourceFiles = getDependenciesSourceFiles(config);
if (sourceFiles.length > 0) {
System.out.println("Compiling " + sourceFiles.length + " " +
"source file" + (sourceFiles.length == 1 ? "" : "s"));
for (String sourceFile : sourceFiles) {
compilerMessage.addAll(compileFile(sourceFile, sourceFiles, dependenciesSourceFiles));
}
if (compilerMessage.size() > 0) {
compilerResult.setCompilerMessages(compilerMessage);
//we want to set it to false only in case we want to fail the build
if (errorLevel.equals(CompilerMessage.Kind.ERROR)) {
compilerResult.setSuccess(false);
}
}
}
return compilerResult;
}
private void init(CompilerConfiguration config) {
//This parameter is passed in the compiler plugin whether to compile the flow with its dependencies
compileWithDependencies = !config.getCustomCompilerArgumentsAsMap().containsKey(IGNORE_DEPENDENCIES);
//This parameter is used to control the error level. if not set only warnings will be shown
errorLevel = config.getCustomCompilerArgumentsAsMap().containsKey(IGNORE_ERRORS) ?
CompilerMessage.Kind.WARNING : CompilerMessage.Kind.ERROR;
}
private List<CompilerMessage> compileFile(String sourceFile, String[] sourceFiles,
Map<String, byte[]> dependenciesSourceFiles) {
ExecutableModellingResult executableModellingResult;
List<CompilerMessage> compilerMessages = new ArrayList<>();
try {
SlangSource slangSource = SlangSource.fromFile(new File(sourceFile));
executableModellingResult = slangCompiler.preCompileSource(slangSource);
if (!CollectionUtils.isEmpty(executableModellingResult.getErrors())) {
for (RuntimeException runtimeException : executableModellingResult.getErrors()) {
compilerMessages.add(new CompilerMessage(sourceFile + ": " +
runtimeException.getMessage(), errorLevel));
}
} else {
if (compileWithDependencies) {
compilerMessages.addAll(validateSlangModelWithDependencies(executableModellingResult,
sourceFiles, dependenciesSourceFiles, sourceFile));
}
}
} catch (Exception e) {
compilerMessages.add(new CompilerMessage(sourceFile + ": " + e.getMessage(), errorLevel));
}
return compilerMessages;
}
private List<CompilerMessage> validateSlangModelWithDependencies(ExecutableModellingResult modellingResult,
String[] dependencies,
Map<String, byte[]> dependenciesSourceFiles,
String sourceFile) {
List<CompilerMessage> compilerMessages = new ArrayList<>();
Set<Executable> dependenciesExecutables = new HashSet<>();
Executable executable = modellingResult.getExecutable();
//we need to verify only flows
if (!executable.getType().equals("flow")) {
return compilerMessages;
}
for (String dependency : dependencies) {
try {
SlangSource slangSource = SlangSource.fromFile(new File(dependency));
modellingResult = slangCompiler.preCompileSource(slangSource);
dependenciesExecutables.add(modellingResult.getExecutable());
} catch (Exception e) {
this.getLogger().warn("Could not compile source: " + dependency);
}
}
for (Map.Entry<String, byte[]> dependencyEntry : dependenciesSourceFiles.entrySet()) {
try {
SlangSource slangSource = SlangSource.fromBytes(dependencyEntry.getValue(), dependencyEntry.getKey());
modellingResult = slangCompiler.preCompileSource(slangSource);
dependenciesExecutables.add(modellingResult.getExecutable());
} catch (Exception e) {
this.getLogger().warn("Could not compile source: " + dependencyEntry.getKey());
}
}
List<RuntimeException> exceptions = slangCompiler.validateSlangModelWithDirectDependencies(executable,
dependenciesExecutables);
for (RuntimeException runtimeException : exceptions) {
compilerMessages.add(new CompilerMessage(sourceFile + ": " + runtimeException.getMessage(), errorLevel));
}
return compilerMessages;
}
public String[] createCommandLine(CompilerConfiguration config) throws CompilerException {
return null;
}
protected static String[] getSourceFiles(CompilerConfiguration config) {
Set<String> sources = new HashSet<>();
for (String sourceLocation : config.getSourceLocations()) {
sources.addAll(getSourceFilesForSourceRoot(config, sourceLocation));
}
return sources.toArray(new String[sources.size()]);
}
private static Map<String, byte[]> getDependenciesSourceFiles(CompilerConfiguration config)
throws CompilerException {
if (config.getClasspathEntries().isEmpty()) {
return Collections.emptyMap();
}
Map<String, byte[]> sources = new HashMap<>();
for (String dependency : config.getClasspathEntries()) {
try {
sources.putAll(getSourceFilesForDependencies(dependency));
} catch (IOException e) {
throw new CompilerException("Cannot load sources from: " + dependency + ". " + e.getMessage());
}
}
return sources;
}
private static Map<String, byte[]> getSourceFilesForDependencies(String dependency) throws IOException {
Path path = Paths.get(dependency);
if (!Files.exists(path) || !path.toString().toLowerCase().endsWith(".jar")) {
return Collections.emptyMap();
}
Map<String, byte[]> sources = new HashMap<>();
try (JarFile jar = new JarFile(dependency)) {
Enumeration enumEntries = jar.entries();
while (enumEntries.hasMoreElements()) {
JarEntry file = (JarEntry) enumEntries.nextElement();
if ((file == null) || (file.isDirectory()) ||
(!file.getName().endsWith(".sl.yaml") &&
!file.getName().endsWith(".sl") && !file.getName().endsWith(".sl.yml"))) {
continue;
}
byte[] bytes;
try (InputStream is = jar.getInputStream(file)) {
bytes = IOUtils.toByteArray(is);
sources.put(file.getName(), bytes);
}
}
}
return sources;
}
// we need to override this as it is hard coded java file extensions
protected static Set<String> getSourceFilesForSourceRoot(CompilerConfiguration config, String sourceLocation) {
Path path = Paths.get(sourceLocation);
if (!Files.exists(path)) {
return emptySet();
}
DirectoryScanner scanner = new DirectoryScanner();
scanner.setBasedir(sourceLocation);
Set<String> includes = config.getIncludes();
if (includes != null && !includes.isEmpty()) {
String[] inclStrs = includes.toArray(new String[includes.size()]);
scanner.setIncludes(inclStrs);
} else {
scanner.setIncludes(new String[]{"**/*.sl.yaml", "**/*.sl", "**/*.sl.yml"});
}
Set<String> configExcludes = config.getExcludes();
if (configExcludes != null && !configExcludes.isEmpty()) {
String[] exclStrs = configExcludes.toArray(new String[configExcludes.size()]);
scanner.setExcludes(exclStrs);
} else {
scanner.setExcludes(new String[]{"**/*prop.sl"});
}
scanner.scan();
String[] sourceDirectorySources = scanner.getIncludedFiles();
Set<String> sources = new HashSet<>();
for (String sourceDirectorySource : sourceDirectorySources) {
sources.add(new File(sourceLocation, sourceDirectorySource).getPath());
}
return sources;
}
}