use of org.finos.legend.engine.shared.javaCompiler.JavaCompileException in project legend-engine by finos.
the class JavaHelper method compilePlanFast.
private static EngineJavaCompiler compilePlanFast(SingleExecutionPlan singleExecutionPlan) throws JavaCompileException, IOException, CompileException {
Map<JavaPlatformImplementation, List<JavaClass>> javaClassesMap = Maps.mutable.empty();
if (singleExecutionPlan.globalImplementationSupport != null) {
JavaPlatformImplementation platformImplementation = (JavaPlatformImplementation) singleExecutionPlan.globalImplementationSupport;
List<JavaClass> globalImplementationSupportClasses = collectJavaClasses(platformImplementation);
if (!globalImplementationSupportClasses.isEmpty()) {
javaClassesMap.put(platformImplementation, globalImplementationSupportClasses);
}
}
collectJavaClasses(singleExecutionPlan.rootExecutionNode, javaClassesMap);
if (javaClassesMap.isEmpty()) {
return null;
}
EngineJavaCompiler javaCompiler = createNewJavaCompiler();
Map<JavaClass, JavaPlatformImplementation> reverseClassMap = Maps.mutable.empty();
List<JavaClass> executeClasses = new ArrayList<>();
List<JavaClass> nonExecuteClasses = new ArrayList<>();
javaClassesMap.forEach((jimpl, jclasses) -> jclasses.forEach(jclass -> {
reverseClassMap.put(jclass, jimpl);
(javaClassHasFullName(jclass, jimpl.executionClassFullName) ? executeClasses : nonExecuteClasses).add(jclass);
}));
Map<String, JavaClass> classMap = nonExecuteClasses.stream().collect(Collectors.toMap(JavaHelper::getJavaClassFullName, x -> x, (x, y) -> {
throw new RuntimeException("Conflicting classes compilation in fast mode not supported!");
}));
Map<String, String> classToBytecodeMap = compileJavaClasses(nonExecuteClasses, javaCompiler);
classToBytecodeMap.forEach((name, bytecode) -> {
JavaClass _class = classMap.get(name);
if (_class == null) {
// Handling Inner Classes only
int firstDollar = name.indexOf('$');
if (firstDollar == -1) {
throw new RuntimeException("Non Inner classes are not supported yet!");
}
JavaClass topClass = classMap.get(name.substring(0, firstDollar));
JavaPlatformImplementation impl = reverseClassMap.get(topClass);
_class = createGeneratedJavaClass(name);
if (impl.classes == null) {
impl.classes = FastList.newListWith(_class);
} else {
impl.classes.add(_class);
}
}
_class.byteCode = bytecode;
});
ClassLoader globalClassLoader = javaCompiler.getClassLoader();
for (JavaClass executeClass : executeClasses) {
if (executeClass.byteCode == null) {
Map<String, byte[]> classes = SingleFileCompiler.compileFile(buildStringJavaSource(executeClass), globalClassLoader);
executeClass.byteCode = Base64.getEncoder().encodeToString(classes.get(getJavaClassFullName(executeClass)));
}
}
return javaCompiler;
}
use of org.finos.legend.engine.shared.javaCompiler.JavaCompileException in project legend-engine by finos.
the class JavaHelper method compilePlan.
public static EngineJavaCompiler compilePlan(SingleExecutionPlan singleExecutionPlan, MutableList<CommonProfile> pm) throws JavaCompileException {
try {
long start = System.currentTimeMillis();
LOGGER.info(new LogInfo(pm, LoggingEventType.JAVA_COMPILATION_START, "Compile Plan").toString());
EngineJavaCompiler compiler;
try {
compiler = compilePlanFast(singleExecutionPlan);
} catch (Exception ignored) {
// TODO Confirm we can delete this
compiler = compilePlanSlow(singleExecutionPlan);
}
LOGGER.info(new LogInfo(pm, LoggingEventType.JAVA_COMPILATION_STOP, (double) System.currentTimeMillis() - start).toString());
return compiler;
} catch (Exception e) {
LOGGER.info(new LogInfo(pm, LoggingEventType.JAVA_COMPILATION_ERROR, new ErrorResult(1, e).getMessage()).toString());
throw e;
}
}
use of org.finos.legend.engine.shared.javaCompiler.JavaCompileException in project legend-engine by finos.
the class ServiceTestRunner method executeTestAsserts.
@Prometheus(name = "service test execute", doc = "Execution duration summary within service test execution")
private RichServiceTestResult executeTestAsserts(SingleExecutionPlan executionPlan, List<TestContainer> asserts, RichIterable<? extends String> sqlStatements, Scope scope) throws IOException {
long start = System.currentTimeMillis();
if (ExecutionNodeTDSResultHelper.isResultTDS(executionPlan.rootExecutionNode) || (executionPlan.rootExecutionNode.isResultPrimitiveType() && "String".equals(executionPlan.rootExecutionNode.getDataTypeResultType()))) {
// Java
String packageName = "org.finos.legend.tests.generated";
String className = "TestSuite";
String javaCode = ServiceTestGenerationHelper.generateJavaForAsserts(asserts, this.service, this.pureModel, packageName, className);
Class<?> assertsClass;
RichServiceTestResult testRun;
try {
assertsClass = compileJavaForAsserts(packageName, className, javaCode);
} catch (JavaCompileException e) {
MetricsHandler.incrementErrorCount("test_execute", 0);
throw new RuntimeException("Error compiling test asserts for " + this.service.getPath(), e);
}
scope.span().log("Java asserts generated and compiled");
TestExecutionScope execScope = null;
try {
// Setup test database if needed
if (sqlStatements != null) {
execScope = TestExecutionScope.setupTestServer(sqlStatements, scope);
}
// Run tests
Map<String, TestResult> results = Maps.mutable.empty();
Map<String, Exception> assertExceptions = Maps.mutable.empty();
for (Pair<TestContainer, Integer> tc : LazyIterate.zipWithIndex(asserts)) {
// Build Param Map
Map<String, Result> parameters = Maps.mutable.empty();
if (this.service.execution instanceof PureExecution) {
parameters = ListIterate.zip(((PureExecution) this.service.execution).func.parameters, tc.getOne().parametersValues).toMap(p -> p.getOne().name, p -> // Condition evoked in case of studio-flow
p.getTwo() instanceof Collection ? new ConstantResult(ListIterate.collect(((Collection) p.getTwo()).values, v -> v.accept(new ValueSpecificationToResultVisitor()).getValue())) : // Condition evoked in case of pureIDE-flow
p.getTwo() instanceof PureList ? new ConstantResult(ListIterate.collect(((PureList) p.getTwo()).values, v -> v.accept(new ValueSpecificationToResultVisitor()).getValue())) : p.getTwo().accept(new ValueSpecificationToResultVisitor()));
}
// Execute Plan
ExecutionState testExecutionState = new ExecutionState(parameters, Lists.mutable.withAll(executionPlan.templateFunctions), Lists.mutable.with(new RelationalStoreExecutionState(new RelationalStoreState(execScope == null ? -1 : execScope.getPort())), new InMemoryStoreExecutionState(new InMemoryStoreState()), new ServiceStoreExecutionState(new ServiceStoreState())));
Result result = this.executor.execute(executionPlan, testExecutionState, null, null);
org.finos.legend.pure.m3.coreinstance.meta.pure.mapping.Result<Object> pureResult = result.accept(new ResultToPureResultVisitor());
// Execute Assert
String testName = ServiceTestGenerationHelper.getAssertMethodName(tc.getTwo());
scope.span().setTag(testName, resultToString(pureResult, this.pureModel.getExecutionSupport()));
TestResult testResult;
try {
Boolean assertResult = (Boolean) assertsClass.getMethod(testName, org.finos.legend.pure.m3.coreinstance.meta.pure.mapping.Result.class, ExecutionSupport.class).invoke(null, pureResult, pureModel.getExecutionSupport());
testResult = assertResult ? TestResult.SUCCESS : TestResult.FAILURE;
scope.span().setTag(testName + "_assert", assertResult);
} catch (Exception e) {
StringWriter out = new StringWriter();
PrintWriter writer = new PrintWriter(out);
e.printStackTrace(writer);
e.printStackTrace();
testResult = TestResult.ERROR;
assertExceptions.put(testName, e);
scope.span().setTag(testName + "_assert", out.toString());
}
results.put(testName, testResult);
}
testRun = new RichServiceTestResult(service.getPath(), results, assertExceptions, null, executionPlan, javaCode);
scope.span().log("Finished running tests " + results);
MetricsHandler.observeServerOperation("test_execute", metricsContext, start, System.currentTimeMillis());
} catch (Exception e) {
LOGGER.error("Error running tests", e);
MetricsHandler.incrementErrorCount("test_execute", 0);
throw (e instanceof RuntimeException) ? (RuntimeException) e : new RuntimeException(e);
} finally {
if (execScope != null) {
execScope.close();
}
MetricsHandler.observe("service test execute", start, System.currentTimeMillis());
}
return testRun;
} else {
return new RichServiceTestResult(this.service.getPath(), Collections.emptyMap(), Collections.emptyMap(), null, executionPlan, "");
}
}
use of org.finos.legend.engine.shared.javaCompiler.JavaCompileException in project legend-engine by finos.
the class JavaHelper method compileImplementation.
private static void compileImplementation(JavaPlatformImplementation javaPlatformImplementation, EngineJavaCompiler javaCompiler) throws JavaCompileException {
List<JavaClass> allJavaClasses = collectJavaClasses(javaPlatformImplementation);
if (!allJavaClasses.isEmpty()) {
Map<String, String> classToBytecodeMap = compileJavaClasses(allJavaClasses, javaCompiler);
Map<String, JavaClass> classMap = allJavaClasses.stream().collect(Collectors.toMap(JavaHelper::getJavaClassFullName, x -> x));
classToBytecodeMap.forEach((name, bytecode) -> {
JavaClass _class = classMap.get(name);
if (_class == null) {
_class = createGeneratedJavaClass(name);
if (javaPlatformImplementation.classes == null) {
javaPlatformImplementation.classes = FastList.newListWith(_class);
} else {
javaPlatformImplementation.classes.add(_class);
}
}
_class.byteCode = bytecode;
});
}
}
use of org.finos.legend.engine.shared.javaCompiler.JavaCompileException in project legend-engine by finos.
the class ServiceModeling method testService.
@Prometheus(name = "service test model resolve", doc = "Model resolution duration summary within service test execution")
public List<TestResult> testService(MutableList<CommonProfile> profiles, PureModelContext context, String metricsContext) {
try {
long start = System.currentTimeMillis();
PureModelContextData data = ((PureModelContextData) context).shallowCopy();
Service service = (Service) Iterate.detect(data.getElements(), e -> e instanceof Service);
PureModelContextData dataWithoutService = PureModelContextData.newBuilder().withOrigin(data.getOrigin()).withSerializer(data.getSerializer()).withElements(LazyIterate.select(data.getElements(), e -> e != service)).build();
PureModel pureModel = new PureModel(dataWithoutService, profiles, deploymentMode);
Pair<PureModelContextData, PureModel> pureModelAndData = Tuples.pair(dataWithoutService, pureModel);
long end = System.currentTimeMillis();
MetricsHandler.observe("service test model resolve", start, end);
MetricsHandler.observeServerOperation("model_resolve", metricsContext, start, end);
if (service.execution instanceof PureMultiExecution) {
throw new UnsupportedOperationException("MultiExecutions not yet supported");
}
Root_meta_legend_service_metamodel_Service pureService = compileService(service, pureModel.getContext(service));
TestRun testRun = executeTests(service, pureService, pureModelAndData, PureClientVersions.production, metricsContext);
if (!(testRun instanceof SingleTestRun)) {
throw new UnsupportedOperationException("Expected a single test run result");
}
return ((SingleTestRun) testRun).results.entrySet().stream().map(x -> new TestResult(x.getKey(), x.getValue())).collect(Collectors.toList());
} catch (IOException | JavaCompileException e) {
MetricsHandler.incrementErrorCount("model_resolve", 0);
throw new RuntimeException(e);
}
}
Aggregations