/** * Returns the InvocationSequenceData of GlobalContext Tag. * * @param leafTag * leafTag for which the InvocationSequenceData should be returned * @return InvocationSequenceData of GlobalContext */ private Optional<InvocationSequenceData> getGlobalContext(Tag leafTag) { while (null != leafTag) { if (leafTag.getType().equals(RuleConstants.DIAGNOSIS_TAG_GLOBAL_CONTEXT)) { if (leafTag.getValue() instanceof InvocationSequenceData) { return Optional.of((InvocationSequenceData) leafTag.getValue()); } else { throw new RuntimeException("Global context has wrong datatype!"); } } leafTag = leafTag.getParent(); } return Optional.empty(); }
/** * Returns the CauseStructure of the CauseStructure Tag. * * @param leafTag * leafTag for which the CauseStructure should be returned * @return CauseStructure of leafTag */ private Optional<CauseStructure> getCauseStructure(Tag leafTag) { while (null != leafTag) { if (leafTag.getType().equals(RuleConstants.DIAGNOSIS_TAG_CAUSE_STRUCTURE)) { if (leafTag.getValue() instanceof CauseStructure) { return Optional.of((CauseStructure) leafTag.getValue()); } else { throw new RuntimeException("Cause structure has wrong datatype!"); } } leafTag = leafTag.getParent(); } return Optional.empty(); } }
/** * Returns the InvocationSequenceData of ProblemContext Tag. * * @param leafTag * leafTag for which the InvocationSequenceData should be returned * @return InvocationSequenceData of ProblemContext */ private Optional<CauseCluster> getProblemContext(Tag leafTag) { while (null != leafTag) { if (leafTag.getType().equals(RuleConstants.DIAGNOSIS_TAG_PROBLEM_CONTEXT)) { if (leafTag.getValue() instanceof CauseCluster) { return Optional.of((CauseCluster) leafTag.getValue()); } else { throw new RuntimeException("Problem context has wrong datatype!"); } } leafTag = leafTag.getParent(); } return Optional.empty(); }
/** * Returns the AggregatedInvocationSequenceData of RootCauseInvocations Tag. * * @param leafTag * leafTag for which the AggregatedInvocationSequenceData should be returned * @return AggregatedInvocationSequenceData of RootCauseInvocations */ private Optional<AggregatedDiagnosisData> getRootCauseInvocations(Tag leafTag) { while (null != leafTag) { if (leafTag.getType().equals(RuleConstants.DIAGNOSIS_TAG_PROBLEM_CAUSE)) { if (leafTag.getValue() instanceof AggregatedDiagnosisData) { return Optional.of((AggregatedDiagnosisData) leafTag.getValue()); } else { throw new RuntimeException("Problem cause has wrong datatype!"); } } leafTag = leafTag.getParent(); } return Optional.empty(); }
@Test public void validRootTagInput() { rocks.inspectit.server.diagnosis.engine.tag.Tag tag = rocks.inspectit.server.diagnosis.engine.tag.Tags.rootTag("TestInput"); assertThat(tag.getType(), equalTo(rocks.inspectit.server.diagnosis.engine.tag.Tags.ROOT_TAG)); assertThat(tag.getValue().toString(), equalTo("TestInput")); assertThat(tag.getParent(), equalTo(null)); assertThat(tag.getState(), equalTo(TagState.LEAF)); }
@Test public void nullParentTag() { Collection<rocks.inspectit.server.diagnosis.engine.tag.Tag> tags = rocks.inspectit.server.diagnosis.engine.tag.Tags.tags("A", null, "TestInput1", "TestInput2"); rocks.inspectit.server.diagnosis.engine.tag.Tag[] tagArray = tags.toArray(new rocks.inspectit.server.diagnosis.engine.tag.Tag[0]); assertThat(tags, hasSize(2)); assertThat(tagArray[0].getType(), equalTo("A")); assertThat(tagArray[1].getType(), equalTo("A")); assertThat(tagArray[0].getValue().toString(), equalTo("TestInput1")); assertThat(tagArray[1].getValue().toString(), equalTo("TestInput2")); assertThat(tagArray[0].getParent(), equalTo(null)); assertThat(tagArray[1].getParent(), equalTo(null)); assertThat(tagArray[0].getState(), equalTo(TagState.LEAF)); assertThat(tagArray[1].getState(), equalTo(TagState.LEAF)); }
@Test public void nullRootTagInput() { rocks.inspectit.server.diagnosis.engine.tag.Tag tag = rocks.inspectit.server.diagnosis.engine.tag.Tags.rootTag(null); assertThat(tag.getType(), equalTo(rocks.inspectit.server.diagnosis.engine.tag.Tags.ROOT_TAG)); assertThat(tag.getValue(), equalTo(null)); assertThat(tag.getParent(), equalTo(null)); assertThat(tag.getState(), equalTo(TagState.LEAF)); } }
@Test public void nullParentTag() { rocks.inspectit.server.diagnosis.engine.tag.Tag tag = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "TestInput"); assertThat(tag.getType(), equalTo("A")); assertThat(tag.getValue().toString(), equalTo("TestInput")); assertThat(tag.getParent(), equalTo(null)); assertThat(tag.getState(), equalTo(TagState.LEAF)); }
@Test public void withParentTag() { rocks.inspectit.server.diagnosis.engine.tag.Tag tagA = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "TestInput"); assertThat(tagA.getState(), equalTo(TagState.LEAF)); rocks.inspectit.server.diagnosis.engine.tag.Tag tagB = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("B", "TestInput", tagA); assertThat(tagB.getType(), equalTo("B")); assertThat(tagB.getValue().toString(), equalTo("TestInput")); assertThat(tagB.getParent(), equalTo(tagA)); assertThat(tagB.getState(), equalTo(TagState.LEAF)); assertThat(tagA.getState(), equalTo(TagState.PARENT)); } }
@Test public void withParentTag() { rocks.inspectit.server.diagnosis.engine.tag.Tag tagA = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "TestInput"); Collection<rocks.inspectit.server.diagnosis.engine.tag.Tag> tags = rocks.inspectit.server.diagnosis.engine.tag.Tags.tags("B", tagA, "TestInput1", "TestInput2"); rocks.inspectit.server.diagnosis.engine.tag.Tag[] tagArray = tags.toArray(new rocks.inspectit.server.diagnosis.engine.tag.Tag[0]); assertThat(tags, hasSize(2)); assertThat(tagArray[0].getType(), equalTo("B")); assertThat(tagArray[1].getType(), equalTo("B")); assertThat(tagArray[0].getValue().toString(), equalTo("TestInput1")); assertThat(tagArray[1].getValue().toString(), equalTo("TestInput2")); assertThat(tagArray[0].getParent(), equalTo(tagA)); assertThat(tagArray[1].getParent(), equalTo(tagA)); assertThat(tagArray[0].getState(), equalTo(TagState.LEAF)); assertThat(tagArray[1].getState(), equalTo(TagState.LEAF)); assertThat(tagA.getState(), equalTo(TagState.PARENT)); } }
@Test public void fromActivated() throws Exception { session = new Session<>(Rules.define(RuleA.class, RuleB.class, RuleC.class), new DefaultSessionResultCollector<String>()); String input = "input"; session.activate(input, Session.EMPTY_SESSION_VARIABLES); DefaultSessionResult<String> result = session.call(); assertThat(session.getState(), equalTo(State.PROCESSED)); assertThat(result.getConditionFailures().keys(), empty()); assertThat(result.getEndTags().keySet(), containsInAnyOrder("C")); assertThat(result.getEndTags().get("C"), hasSize(1)); assertThat(((Integer) result.getEndTags().get("C").iterator().next().getValue()), equalTo((input.length() * 2) + 2)); }
@Test public void simpleRuleExecution() throws RuleDefinitionException, RuleExecutionException { RuleDefinition ruleDefinition = Rules.define(RuleA.class); String inputStr = "hallo"; RuleInput input = new RuleInput(Tags.tag(Tags.ROOT_TAG, inputStr)); RuleOutput output = ruleDefinition.execute(input, Collections.<String, Object> emptyMap()); assertThat(output.getRuleName(), equalTo(ruleDefinition.getName())); assertThat(output.getTags(), hasSize(1)); assertThat(output.getTags().iterator().next().getValue(), equalTo((Object) (inputStr + inputStr))); }
@Test public void ruleWithSessionVariableExecution() throws RuleDefinitionException, RuleExecutionException { RuleDefinition ruleDefinition = Rules.define(RuleWithSessionVariable.class); String inputStr = "hallo"; String sessionVar = "sessionVar"; RuleInput input = new RuleInput(Tags.tag(Tags.ROOT_TAG, inputStr)); RuleOutput output = ruleDefinition.execute(input, Collections.singletonMap(sessionVar, (Object) sessionVar)); assertThat(output.getRuleName(), equalTo(ruleDefinition.getName())); assertThat(output.getTags(), hasSize(1)); assertThat(output.getTags().iterator().next().getValue(), equalTo((Object) (inputStr + sessionVar))); }
@Test public void ruleWithConditionSuccessExecution() throws RuleDefinitionException, RuleExecutionException { RuleDefinition ruleDefinition = Rules.define(RuleF.class); String inputStrA = "hallo"; String inputStrE = "again"; Tag tagA = Tags.tag("A", inputStrA); Tag tagE = Tags.tag("E", inputStrE); RuleInput inputE = new RuleInput(tagE, Arrays.asList(tagA, tagE)); RuleOutput output = ruleDefinition.execute(inputE, Collections.<String, Object> emptyMap()); assertThat(output.getRuleName(), equalTo(ruleDefinition.getName())); assertThat(output.getTags(), hasSize(1)); assertThat(output.getTags().iterator().next().getValue(), equalTo((Object) (inputStrA + inputStrE))); }
/** * {@inheritDoc} * * @throws RuleExecutionException * If tag injection fails. */ @Override public Object determineValueToInject(ExecutionContext context) throws RuleExecutionException { // extract the required type form the unraveled list of input Tags for (Tag tag : context.getRuleInput().getUnraveled()) { if (tag.getType().equals(getType())) { return InjectionStrategy.BY_VALUE.equals(getInjectionStrategy()) ? tag.getValue() : tag; } } throw new RuleExecutionException("Unable to find Tag: " + getType() + " in RuleInput.", context); }
@Test public void testEngine() throws DiagnosisEngineException { final List<DefaultSessionResult<String>> results = new ArrayList<>(); final List<Throwable> exceptions = new ArrayList<>(); DiagnosisEngineConfiguration<String, DefaultSessionResult<String>> configuration = new DiagnosisEngineConfiguration<String, DefaultSessionResult<String>>().setNumSessionWorkers(1) .addRuleClasses(RuleA.class, RuleB.class, RuleC.class, RuleE.class).setStorageClass(DefaultRuleOutputStorage.class).setResultCollector(new DefaultSessionResultCollector<String>()) .addSessionCallback(new ISessionCallback<DefaultSessionResult<String>>() { @Override public void onSuccess(DefaultSessionResult<String> result) { results.add(result); } @Override public void onFailure(Throwable t) { exceptions.add(t); } }); configuration.setShutdownTimeout(6000); DiagnosisEngine<String, DefaultSessionResult<String>> diagnosisEngine = new DiagnosisEngine<>(configuration); String input = "Trace"; diagnosisEngine.analyze(input); diagnosisEngine.shutdown(true); assertThat(exceptions, empty()); assertThat(results.get(0).getEndTags().get("C"), hasSize(1)); assertThat(results.get(0).getEndTags().get("C").iterator().next().getValue(), equalTo((Object) ((input + input).length() + 2))); assertThat(results.get(0).getEndTags().get("E"), hasSize(1)); assertThat(results.get(0).getEndTags().get("E").iterator().next().getValue(), equalTo((Object) (input + "E"))); }