public PlannerException( RuleRegistry registry, PlanPhase phase, Rule rule, ElementGraph elementGraph, Throwable throwable ) { super( "registry: " + registry.getName() + ", phase: " + phase + ", failed on rule: " + rule.getRuleName() + ( elementGraph != null ? ", see attached source element-graph" : "" ), throwable ); this.elementGraph = elementGraph; }
public PlannerException( RuleRegistry registry, PlanPhase phase, Rule rule, Throwable throwable ) { super( "registry: " + registry.getName() + ", phase: " + phase + ", failed on rule: " + rule.getRuleName(), throwable ); }
public void writeFinal( String fileName, RuleResult ruleResult ) { Path path = getPlanTracePath(); if( path == null ) return; Path filePath = path.resolve( String.format( "%s-%s.txt", fileName, ruleResult.getRegistry().getName() ) ); File file = filePath.toFile(); processLogger.logInfo( "writing final registry: {}", file ); try( PrintWriter writer = new PrintWriter( file ) ) { writer.println( "filename names winning rule registry" ); } catch( IOException exception ) { processLogger.logError( "could not write final registry", exception ); } }
private void notifyUnsupported() { if( unsupported.isEmpty() ) return; for( RuleResult ruleResult : unsupported ) getFlowLogger().logInfo( "rule registry: {}, does not support assembly", ruleResult.getRegistry().getName() ); if( !registrySet.isIgnoreFailed() || success.isEmpty() && illegal.isEmpty() && interrupted.isEmpty() ) rethrow( unsupported.get( 0 ).getPlannerException() ); }
private void notifyIllegal() { if( illegal.isEmpty() ) return; for( RuleResult ruleResult : illegal ) getFlowLogger().logInfo( "rule registry: {}, found assembly to be malformed", ruleResult.getRegistry().getName() ); if( !registrySet.isIgnoreFailed() || success.isEmpty() ) rethrow( illegal.get( 0 ).getPlannerException() ); }
private void writePhaseInitPlan( PlanPhase phase, RuleResult ruleResult ) { switch( phase.getLevel() ) { case Assembly: traceWriter.writeTransformPlan( registry.getName(), ruleResult.getAssemblyGraph(), format( "%02d-%s-init.dot", phase.ordinal(), phase ) ); break; case Step: break; case Node: break; case Pipeline: break; } }
private void writePhaseResultPlan( PlanPhase phase, RuleResult ruleResult ) { switch( phase.getLevel() ) { case Assembly: traceWriter.writeTransformPlan( registry.getName(), ruleResult.getAssemblyGraph(), format( "%02d-%s-result.dot", phase.ordinal(), phase ) ); break; case Step: traceWriter.writeTransformPlan( registry.getName(), ruleResult.getAssemblyToStepGraphMap().get( ruleResult.getAssemblyGraph() ), phase, "result" ); break; case Node: traceWriter.writeTransformPlan( registry.getName(), ruleResult.getStepToNodeGraphMap(), phase, "result" ); break; case Pipeline: traceWriter.writeTransformPlan( registry.getName(), ruleResult.getStepToNodeGraphMap(), ruleResult.getNodeToPipelineGraphMap(), phase, "result" ); break; } }
private void notifyInterrupted() { if( interrupted.isEmpty() ) return; for( RuleResult ruleResult : interrupted ) getFlowLogger().logInfo( "rule registry: {}, planned longer than default duration, was cancelled", ruleResult.getRegistry().getName() ); if( interrupted.size() == registrySet.size() ) throw new PlannerException( "planner registry timeout exceeded for all registries: " + formatDurationFromMillis( registrySet.getPlannerTimeoutSec() * 1000 ) ); if( !registrySet.isIgnoreFailed() || success.isEmpty() ) rethrow( interrupted.get( 0 ).getPlannerException() ); }
private RuleResult selectSuccess() { if( success.isEmpty() ) throw new IllegalStateException( "no planner results from registry set" ); for( RuleResult ruleResult : success ) getFlowLogger().logInfo( "rule registry: {}, supports assembly with steps: {}, nodes: {}", ruleResult.getRegistry().getName(), ruleResult.getNumSteps(), ruleResult.getNumNodes() ); if( success.size() != 1 ) { // sort is stable Collections.sort( success, getOrderComparator() ); Collections.sort( success, getPlanComparator() ); } RuleResult ruleResult = success.get( 0 ); if( registrySet.getSelect() == RuleRegistrySet.Select.FIRST ) getFlowLogger().logInfo( "rule registry: {}, result was selected as first successful", ruleResult.getRegistry().getName() ); else if( registrySet.getSelect() == RuleRegistrySet.Select.COMPARED ) getFlowLogger().logInfo( "rule registry: {}, result was selected using: \'{}\'", ruleResult.getRegistry().getName(), getPlanComparator().toString() ); return ruleResult; }
private void writeTransformTrace( RuleResult ruleResult, PlanPhase phase, Rule rule, ElementGraph parent, ElementGraph child, GraphResult result ) { if( traceWriter.isTransformTraceDisabled() ) return; int[] path = child != null ? ruleResult.getPathFor( parent, child ) : ruleResult.getPathFor( parent ); traceWriter.writeTransformPlan( registry.getName(), phase, rule, path, result ); } }
public void writeStats( PlannerContext plannerContext, RuleResult ruleResult ) { Path path = getPlanStatsPath(); if( path == null ) return; File file = path.resolve( String.format( "planner-stats-%s-%s.txt", ruleResult.getRegistry().getName(), ruleResult.getResultStatus() ) ).toFile(); processLogger.logInfo( "writing planner stats to: {}", file ); file.getParentFile().mkdirs(); try( PrintWriter writer = new PrintWriter( file ) ) { Flow flow = plannerContext.getFlow(); Map<Object, Object> configAsProperties = flow.getConfigAsProperties(); writer.format( "cascading version: %s, build: %s\n", emptyOrValue( Version.getReleaseFull() ), emptyOrValue( Version.getReleaseBuild() ) ); writer.format( "application id: %s\n", emptyOrValue( AppProps.getApplicationID( configAsProperties ) ) ); writer.format( "application name: %s\n", emptyOrValue( AppProps.getApplicationName( configAsProperties ) ) ); writer.format( "application version: %s\n", emptyOrValue( AppProps.getApplicationVersion( configAsProperties ) ) ); writer.format( "platform: %s\n", emptyOrValue( flow.getPlatformInfo() ) ); writer.format( "frameworks: %s\n", emptyOrValue( AppProps.getApplicationFrameworks( configAsProperties ) ) ); writer.println(); ruleResult.writeStats( writer ); } catch( IOException exception ) { processLogger.logError( "could not write stats", exception ); } }
public RuleResult exec( PlannerContext plannerContext, FlowElementGraph flowElementGraph ) { RuleResult ruleResult = new RuleResult( registry, flowElementGraph ); ProcessLogger logger = plannerContext.getLogger(); int size = flowElementGraph.vertexSet().size(); boolean logAsInfo = size >= ELEMENT_THRESHOLD; if( logAsInfo ) logger.logInfo( "elements in graph: {}, info logging threshold: {}, logging planner execution status", size, ELEMENT_THRESHOLD ); long beginExec = System.currentTimeMillis(); try { planPhases( plannerContext, logAsInfo, ruleResult ); } catch( Exception exception ) { ruleResult.setPlannerException( exception ); } finally { long endExec = System.currentTimeMillis(); ruleResult.setDuration( beginExec, endExec ); RuleResult.ResultStatus status = ruleResult.getResultStatus(); String duration = formatDurationFromMillis( endExec - beginExec ); logPhase( logger, logAsInfo, "rule registry completed: {}, with status: {}, and duration: {}", registry.getName(), status, duration ); } return ruleResult; }
String registryName = ruleResult.getRegistry().getName();
protected RuleResult execPlannerFor( RuleRegistry ruleRegistry ) { flowPlanner.configRuleRegistryDefaults( ruleRegistry ); String registryName = ruleRegistry.getName(); RuleExec ruleExec = new RuleExec( traceWriter, ruleRegistry ); PlannerContext plannerContext = new PlannerContext( ruleRegistry, flowPlanner, flowDef, flow, traceWriter.isTransformTraceEnabled() ); RuleResult ruleResult = ruleExec.exec( plannerContext, flowElementGraph ); getFlowLogger().logInfo( "executed rule registry: {}, completed as: {}, in: {}", registryName, ruleResult.getResultStatus(), formatDurationFromMillis( ruleResult.getDuration() ) ); traceWriter.writeTracePlan( registryName, "completed-flow-element-graph", ruleResult.getAssemblyGraph() ); traceWriter.writeStats( plannerContext, ruleResult ); Exception plannerException; if( ruleResult.isSuccess() ) plannerException = flowPlanner.verifyResult( ruleResult ); else plannerException = ruleResult.getPlannerException(); // will be re-thrown below if( plannerException != null && plannerException instanceof PlannerException && ( (PlannerException) plannerException ).getElementGraph() != null ) traceWriter.writeTracePlan( registryName, "failed-source-element-graph", ( (PlannerException) plannerException ).getElementGraph() ); if( ruleResult.isSuccess() && plannerException != null ) rethrow( plannerException ); return ruleResult; }
traceWriter.writeTracePlanSteps( "4-final-flow-steps", flowStepGraph ); flow.setPlannerInfo( getPlannerInfo( ruleResult.getRegistry().getName() ) );