/*******************************************************************************
* (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.lang.cli;
import com.google.common.collect.Lists;
import io.cloudslang.lang.cli.services.ScoreServices;
import io.cloudslang.lang.cli.utils.CompilerHelper;
import io.cloudslang.lang.cli.utils.MetadataHelper;
import io.cloudslang.lang.compiler.modeller.result.CompilationModellingResult;
import io.cloudslang.lang.entities.CompilationArtifact;
import io.cloudslang.lang.entities.ScoreLangConstants;
import io.cloudslang.lang.entities.SystemProperty;
import io.cloudslang.lang.entities.bindings.Input;
import io.cloudslang.lang.entities.bindings.values.Value;
import io.cloudslang.lang.runtime.events.LanguageEventData;
import io.cloudslang.score.events.EventConstants;
import io.cloudslang.score.events.ScoreEvent;
import io.cloudslang.score.events.ScoreEventListener;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang.time.StopWatch;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.shell.core.CommandMarker;
import org.springframework.shell.core.annotation.CliCommand;
import org.springframework.shell.core.annotation.CliOption;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.io.File;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @author lesant
* @version $Id$
* @since 11/07/2014
*/
@Component
public class SlangCli implements CommandMarker {
private static final Logger logger = Logger.getLogger(SlangCli.class);
private static final String TRIGGERED_FLOW_MSG = "Triggered flow : ";
private static final String WITH_EXECUTION_ID_MSG = "Execution id: ";
private static final String FLOW_EXECUTION_TIME_TOOK = ", duration: ";
private static final String CURRENTLY = "You are CURRENTLY running CloudSlang version: ";
private static final String RUN_HELP = "triggers a CloudSlang flow";
private static final String FILE_HELP = "Path to filename. e.g. run --f c:/.../your_flow.sl";
private static final String CLASSPATH_HELP = "Classpath, a directory comma separated list to flow dependencies, " +
"by default it will take flow file dir. " +
"e.g. run --f c:/.../your_flow.sl --i input1=root,input2=25 --cp c:/.../yaml";
private static final String INPUTS_HELP = "inputs in a key=value comma separated list. " +
"e.g. run --f c:/.../your_flow.sl --i input1=root,input2=25";
private static final String INPUT_FILE_HELP = "comma separated list of input file locations. " +
"e.g. run --f C:/.../your_flow.sl --if C:/.../inputs.yaml";
private static final String SYSTEM_PROPERTY_FILE_HELP = "comma separated list of system property file locations. " +
"e.g. run --f c:/.../your_flow.sl --spf c:/.../yaml";
private static final String ENV_HELP = "Set environment var relevant to the CLI";
private static final String SET_ASYNC_HELP = "set the async. e.g. env --setAsync true";
private static final String CSLANG_VERSION_HELP = "Prints the CloudSlang version used";
private static final String INPUTS_COMMAND_HELP = "Get flow inputs";
private static final String PATH_TO_FILENAME_HELP = "Path to filename. e.g. /path/to/file.sl";
private static final String QUIET = "quiet";
private static final String DEBUG = "debug";
private static final String DEFAULT = "default";
@Autowired
private ScoreServices scoreServices;
@Autowired
private CompilerHelper compilerHelper;
@Autowired
private MetadataHelper metadataHelper;
@org.springframework.beans.factory.annotation.Value("${slang.version}")
private String slangVersion;
/**
* This global param holds the state of the CLI, if flows need to run in ASYNC or in SYNC manner.
*/
private Boolean triggerAsync = false;
@CliCommand(value = "run", help = RUN_HELP)
public String run(
@CliOption(key = {"", "f", "file"}, mandatory = true, help = FILE_HELP) final File file,
@CliOption(key = {"cp", "classpath"}, mandatory = false, help = CLASSPATH_HELP)
final List<String> classPath,
@CliOption(key = {"i", "inputs"}, mandatory = false, help = INPUTS_HELP)
final Map<String, ? extends Serializable> inputs,
@CliOption(key = {"if", "input-file"}, mandatory = false, help = INPUT_FILE_HELP)
final List<String> inputFiles,
@CliOption(key = {"v", "verbose"}, mandatory = false,
help = "default, quiet, debug(print each step outputs). e.g. run --f c:/.../your_flow.sl --v quiet",
specifiedDefaultValue = "debug", unspecifiedDefaultValue = "default") final String verbose,
@CliOption(key = {"spf", "system-property-file"}, mandatory = false, help = SYSTEM_PROPERTY_FILE_HELP)
final List<String> systemPropertyFiles) {
if (invalidVerboseInput(verbose)) {
throw new IllegalArgumentException("Verbose argument is invalid.");
}
CompilationArtifact compilationArtifact = compilerHelper.compile(file.getAbsolutePath(), classPath);
Set<SystemProperty> systemProperties = compilerHelper.loadSystemProperties(systemPropertyFiles);
Map<String, Value> inputsFromFile = compilerHelper.loadInputsFromFile(inputFiles);
Map<String, Value> mergedInputs = new HashMap<>();
if (MapUtils.isNotEmpty(inputsFromFile)) {
mergedInputs.putAll(inputsFromFile);
}
if (MapUtils.isNotEmpty(inputs)) {
mergedInputs.putAll(io.cloudslang.lang.entities.utils.MapUtils.convertMapNonSensitiveValues(inputs));
}
boolean quiet = QUIET.equalsIgnoreCase(verbose);
boolean debug = DEBUG.equalsIgnoreCase(verbose);
Long id;
if (!triggerAsync) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
id = scoreServices.triggerSync(compilationArtifact, mergedInputs, systemProperties, quiet, debug);
stopWatch.stop();
return quiet ? StringUtils.EMPTY : triggerSyncMsg(id, stopWatch.toString());
}
id = scoreServices.trigger(compilationArtifact, mergedInputs, systemProperties);
return quiet ? StringUtils.EMPTY : triggerAsyncMsg(id, compilationArtifact.getExecutionPlan().getName());
}
private boolean invalidVerboseInput(String verbose) {
String[] validArguments = {DEFAULT, QUIET, DEBUG};
return !Arrays.asList(validArguments).contains(verbose.toLowerCase());
}
@CliCommand(value = "compile", help = "Display compile errors for an executable")
public String compileSource(
@CliOption(key = {"", "d", "directory"}, mandatory = false,
help = "Path to directory. e.g. compile --d c:/.../your_directory")
final List<String> directories,
@CliOption(key = {"", "f", "file"}, mandatory = false,
help = "Path to filename. e.g. compile --f c:/.../your_flow.sl") final File file,
@CliOption(key = {"cp", "classpath"}, mandatory = false, help = CLASSPATH_HELP)
final List<String> classPath
) {
if (directories != null) {
List<CompilationModellingResult> results = compilerHelper.compileFolders(directories);
return printAllCompileErrors(results);
} else if (file != null) {
CompilationModellingResult result = compilerHelper.compileSource(file.getAbsolutePath(), classPath);
return printCompileErrors(result.getErrors(), file, new StringBuilder());
} else {
throw new IllegalArgumentException("You should specify directory(otherwise known as option 'd') " +
"or file(otherwise known as option 'f').");
}
}
private String printAllCompileErrors(List<CompilationModellingResult> results) {
if (results.size() > 0) {
StringBuilder stringBuilder = new StringBuilder();
for (CompilationModellingResult result : results) {
printCompileErrors(result.getErrors(), result.getFile(), stringBuilder);
stringBuilder.append(System.lineSeparator());
}
return stringBuilder.toString();
} else {
return "No files were found to compile.";
}
}
private String printCompileErrors(List<RuntimeException> exceptions, File file, StringBuilder stringBuilder) {
if (exceptions.size() > 0) {
stringBuilder.append("Following exceptions were found:").append(System.lineSeparator());
for (RuntimeException exception : exceptions) {
stringBuilder.append("\t");
stringBuilder.append(exception.getClass());
stringBuilder.append(": ");
stringBuilder.append(exception.getMessage());
stringBuilder.append(System.lineSeparator());
}
throw new RuntimeException(stringBuilder.toString());
} else {
stringBuilder.append("Compilation was successful for ").append(file.getName());
}
return StringUtils.trim(stringBuilder.toString());
}
@CliCommand(value = "inspect", help = "Display metadata about an executable")
public String inspectExecutable(
@CliOption(key = {"", "f", "file"}, mandatory = true, help = PATH_TO_FILENAME_HELP)
final File executableFile
) {
return metadataHelper.extractMetadata(executableFile);
}
@CliCommand(value = "list", help = "List system properties from a properties file")
public String listSystemProperties(
@CliOption(key = {"", "f", "file"}, mandatory = true, help = PATH_TO_FILENAME_HELP)
final String propertiesFile) {
Set<SystemProperty> systemProperties = compilerHelper.loadSystemProperties(Lists.newArrayList(propertiesFile));
return prettyPrintSystemProperties(systemProperties);
}
private String prettyPrintSystemProperties(Set<SystemProperty> systemProperties) {
StringBuilder stringBuilder = new StringBuilder();
if (CollectionUtils.isEmpty(systemProperties)) {
stringBuilder.append("No system properties found.");
} else {
stringBuilder.append("Following system properties were loaded:").append(System.lineSeparator());
for (SystemProperty systemProperty : systemProperties) {
stringBuilder.append("\t");
stringBuilder.append(systemProperty.getFullyQualifiedName());
stringBuilder.append(": ");
stringBuilder.append(systemProperty.getValue());
stringBuilder.append(System.lineSeparator());
}
}
return StringUtils.trim(stringBuilder.toString());
}
@CliCommand(value = "env", help = ENV_HELP)
public String setEnvVar(
@CliOption(key = "setAsync", mandatory = true, help = SET_ASYNC_HELP) final boolean switchAsync) {
triggerAsync = switchAsync;
return setEnvMessage(triggerAsync);
}
@CliCommand(value = "inputs", help = INPUTS_COMMAND_HELP)
public List<String> getFlowInputs(
@CliOption(key = {"", "f", "file"}, mandatory = true, help = FILE_HELP) final File file,
@CliOption(key = {"cp", "classpath"}, mandatory = false, help = CLASSPATH_HELP)
final List<String> classPath) {
CompilationArtifact compilationArtifact = compilerHelper.compile(file.getAbsolutePath(), classPath);
List<Input> inputs = compilationArtifact.getInputs();
List<String> inputsResult = new ArrayList<>();
for (Input input : inputs) {
if (!input.isPrivateInput()) {
inputsResult.add(input.getName());
}
}
return inputsResult;
}
@CliCommand(value = "cslang --version", help = CSLANG_VERSION_HELP)
public String version() {
return CURRENTLY + slangVersion;
}
public static String triggerSyncMsg(Long id, String duration) {
return WITH_EXECUTION_ID_MSG + id + FLOW_EXECUTION_TIME_TOOK + duration;
}
public static String triggerAsyncMsg(Long id, String flowName) {
return TRIGGERED_FLOW_MSG + flowName + WITH_EXECUTION_ID_MSG + id;
}
public static String setEnvMessage(boolean triggerAsync) {
return "flow execution ASYNC execution was changed to : " + triggerAsync;
}
@PostConstruct
private void registerEventHandlers() {
Set<String> slangHandlerTypes = new HashSet<>();
slangHandlerTypes.add(ScoreLangConstants.EVENT_ACTION_START);
slangHandlerTypes.add(ScoreLangConstants.EVENT_ACTION_END);
slangHandlerTypes.add(ScoreLangConstants.EVENT_ACTION_ERROR);
slangHandlerTypes.add(ScoreLangConstants.EVENT_STEP_START);
slangHandlerTypes.add(ScoreLangConstants.EVENT_INPUT_START);
slangHandlerTypes.add(ScoreLangConstants.EVENT_INPUT_END);
slangHandlerTypes.add(ScoreLangConstants.EVENT_ARGUMENT_START);
slangHandlerTypes.add(ScoreLangConstants.EVENT_ARGUMENT_END);
slangHandlerTypes.add(ScoreLangConstants.EVENT_OUTPUT_START);
slangHandlerTypes.add(ScoreLangConstants.EVENT_OUTPUT_END);
slangHandlerTypes.add(ScoreLangConstants.EVENT_BRANCH_START);
slangHandlerTypes.add(ScoreLangConstants.EVENT_BRANCH_END);
slangHandlerTypes.add(ScoreLangConstants.EVENT_SPLIT_BRANCHES);
slangHandlerTypes.add(ScoreLangConstants.EVENT_JOIN_BRANCHES_START);
slangHandlerTypes.add(ScoreLangConstants.EVENT_JOIN_BRANCHES_END);
slangHandlerTypes.add(ScoreLangConstants.SLANG_EXECUTION_EXCEPTION);
slangHandlerTypes.add(ScoreLangConstants.EVENT_EXECUTION_FINISHED);
Set<String> scoreHandlerTypes = new HashSet<>();
scoreHandlerTypes.add(EventConstants.SCORE_FINISHED_EVENT);
scoreHandlerTypes.add(EventConstants.SCORE_ERROR_EVENT);
scoreHandlerTypes.add(EventConstants.SCORE_FAILURE_EVENT);
scoreServices.subscribe(new ScoreEventListener() {
@Override
public void onEvent(ScoreEvent event) {
logSlangEvent(event);
}
}, slangHandlerTypes);
scoreServices.subscribe(new ScoreEventListener() {
@Override
public void onEvent(ScoreEvent event) {
logScoreEvent(event);
}
}, scoreHandlerTypes);
}
private void logSlangEvent(ScoreEvent event) {
LanguageEventData eventData = (LanguageEventData) event.getData();
logger.info(("[ " + eventData.getPath() + " - " + eventData.getStepName() + " ] " +
event.getEventType() + " - Inputs: " + eventData.getInputs() + ", Outputs: " + eventData.getOutputs() +
", Result: " + eventData.getResult() + ", Raw Data: " + event.getData()));
}
private void logScoreEvent(ScoreEvent event) {
logger.info((event.getEventType() + " - " + event.getData()));
}
}