rocks.inspectit.server.diagnosis.engine.rule.RuleOutput java code examples

/**
 * Creates the faked output of an internal rule to start process of other rules. If we wrap the
 * input to be analyzed into a RuleOutput the entire rule processing works exactly the same way
 * and and the input can be access of type {@link Tags#ROOT_TAG}.
 *
 * @param input
 *            The input to be wrapped in output.
 * @return RuleOutput providing the input as value of {@link Tags#ROOT_TAG}.
 */
public static RuleOutput triggerRuleOutput(Object input) {
  return new RuleOutput(TRIGGER_RULE, Tags.ROOT_TAG, Collections.<ConditionFailure> emptyList(), Collections.singleton(Tags.rootTag(input)));
}

@Override
public DefaultSessionResult<I> collect(SessionContext<I> context) {
  Multimap<String, ConditionFailure> conditionFailures = ArrayListMultimap.create();
  //unpack condition errors
  for (RuleOutput output : context.getStorage().getAllOutputsWithConditionFailures().values()) {
    conditionFailures.putAll(output.getRuleName(), output.getConditionFailures());
  }
  return new DefaultSessionResult<>(context.getInput(), conditionFailures, context.getStorage().mapTags(TagState.LEAF));
}

/**
 * {@inheritDoc}
 */
@Override
public Multimap<String, Tag> mapTags(TagState state) {
  Multimap<String, Tag> tags = ArrayListMultimap.create();
  for (Map.Entry<String, RuleOutput> entry : allOutputs.entries()) {
    if (entry.getValue().hasResultTags()) {
      for (Tag tag : entry.getValue().getTags()) {
        if (tag.getState().equals(state)) {
          tags.put(tag.getType(), tag);
        }
      }
    }
  }
  return tags;
}

/**
 * {@inheritDoc}
 */
@Override
public void store(RuleOutput output) {
  if (output.hasConditionFailures()) {
    conditionFailures.put(output.getEmbeddedTagType(), output);
  } else {
    allOutputs.put(output.getEmbeddedTagType(), output);
  }
}

@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 ruleWithConditionFailureExecution() throws RuleDefinitionException, RuleExecutionException {
    RuleDefinition ruleDefinition = Rules.define(RuleG.class);
    String inputStr = "hallo";
    RuleInput input = new RuleInput(Tags.tag("A", inputStr));
    RuleOutput output = ruleDefinition.execute(input, Collections.<String, Object> emptyMap());
    assertThat(output.getRuleName(), equalTo(ruleDefinition.getName()));
    assertThat(output.getConditionFailures(), hasSize(1));
    assertThat(output.getTags(), empty());
  }
}

ConditionFailure cFailure1 = new ConditionFailure("Cond1", "test hint");
ConditionFailure cFailure2 = new ConditionFailure("Cond2", "test hint2");
RuleOutput output1 = new RuleOutput("RuleA", "A", Arrays.asList(cFailure1), Arrays.asList(tagA));
RuleOutput output2 = new RuleOutput("RuleB", "B", Arrays.asList(cFailure2), Arrays.asList(tagB));
RuleOutput output3 = new RuleOutput("RuleC", "C", Collections.<ConditionFailure> emptyList(), Arrays.asList(tagC));
RuleOutput output4 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptyList(), Arrays.asList(tagD1, tagD2));
outputMap.put(output1.getRuleName(), output1);
outputMap.put(output2.getRuleName(), output2);
outputMap.put(output3.getRuleName(), output3);
outputMap.put(output4.getRuleName(), output4);
Multimap<String, Tag> tagMap = ArrayListMultimap.create();
tagMap.put("D", tagD1);

for (Tag leafTag : output.getTags()) {
  Collection<Tag> tags = Tags.unwrap(leafTag, requiredInputTags);
  if (tags.size() == requiredInputTags.size()) {

@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 storeMultipleWithConditionFailures() {
  ConditionFailure failure1 = new ConditionFailure("ConditionX", "SomeHint");
  ConditionFailure failure2 = new ConditionFailure("ConditionY", "SomeHint");
  RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.singleton(failure1), Collections.<Tag> emptySet());
  RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.singleton(failure2), Collections.<Tag> emptySet());
  storage.store(Arrays.asList(outputA, outputB));
  assertThat(storage.getAvailableTagTypes(), empty());
  assertThat(storage.getAllOutputs().keySet(), empty());
  assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(2));
  assertThat(storage.getAllOutputsWithConditionFailures().get("A"), containsInAnyOrder(outputA));
  assertThat(storage.getAllOutputsWithConditionFailures().get("B"), containsInAnyOrder(outputB));
}

@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)));
}

@Test
public void storeWithConditionFailures() {
  ConditionFailure failure = new ConditionFailure("ConditionX", "SomeHint");
  RuleOutput output = new RuleOutput("RuleA", "A", Collections.singleton(failure), Collections.<Tag> emptySet());
  storage.store(output);
  assertThat(storage.getAvailableTagTypes(), empty());
  assertThat(storage.getAllOutputs().keySet(), empty());
  assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(1));
  assertThat(storage.getAllOutputsWithConditionFailures().get("A"), containsInAnyOrder(output));
}

@Test
public void mapSimpleLeafs() {
  Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root");
  Tag tagA = Tags.tag("A", "inputA", rootTag);
  Tag tagB = Tags.tag("B", "inputB", rootTag);
  Tag tagC = Tags.tag("C", "inputC", tagB);
  Tag tagD = Tags.tag("D", "inputD", tagA);
  RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA));
  RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB));
  RuleOutput outputC = new RuleOutput("RuleC", "C", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagC));
  RuleOutput outputD = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD));
  storage.store(Arrays.asList(outputA, outputB, outputC, outputD));
  Multimap<String, Tag> tags = storage.mapTags(TagState.LEAF);
  assertThat(tags.size(), equalTo(2));
  assertThat(tags.keySet(), hasSize(2));
  assertThat(tags.get("A"), empty());
  assertThat(tags.get("B"), empty());
  assertThat(tags.get("C"), containsInAnyOrder(tagC));
  assertThat(tags.get("D"), containsInAnyOrder(tagD));
}

@Test
public void storeWithoutConditionFailures() {
  Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root");
  Tag tagA = Tags.tag("A", "inputA", rootTag);
  RuleOutput output = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA));
  storage.store(output);
  assertThat(storage.getAvailableTagTypes(), containsInAnyOrder("A"));
  assertThat(storage.getAllOutputs().keySet(), hasSize(1));
  assertThat(storage.getAllOutputs().keySet(), containsInAnyOrder("A"));
  assertThat(storage.getAllOutputs().get("A"), containsInAnyOrder(output));
  assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(0));
}

@Test
public void storeWithAndWithoutConditionFailure() {
  ConditionFailure failure = new ConditionFailure("ConditionX", "SomeHint");
  RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.singleton(failure), Collections.<Tag> emptySet());
  Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root");
  Tag tagB = Tags.tag("B", "inputB", rootTag);
  RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB));
  storage.store(Arrays.asList(outputA, outputB));
  assertThat(storage.getAvailableTagTypes(), containsInAnyOrder("B"));
  assertThat(storage.getAllOutputs().keySet(), hasSize(1));
  assertThat(storage.getAllOutputs().keySet(), containsInAnyOrder("B"));
  assertThat(storage.getAllOutputs().get("A"), empty());
  assertThat(storage.getAllOutputs().get("B"), containsInAnyOrder(outputB));
  assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(1));
  assertThat(storage.getAllOutputsWithConditionFailures().get("A"), containsInAnyOrder(outputA));
}

  @Test
  public void mapWithConditionFailuresLeafs() {
    Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root");
    Tag tagA = Tags.tag("A", "inputA", rootTag);
    Tag tagB = Tags.tag("B", "inputB", rootTag);
    Tags.tag("C", "inputC", tagB);
    ConditionFailure failure = new ConditionFailure("ConditionX", "SomeHint");
    Tag tagD = Tags.tag("D", "inputD", tagA);
    RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA));
    RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB));
    RuleOutput outputC = new RuleOutput("RuleC", "C", Collections.singleton(failure), Collections.<Tag> emptySet());
    RuleOutput outputD = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD));
    storage.store(Arrays.asList(outputA, outputB, outputC, outputD));
    Multimap<String, Tag> tags = storage.mapTags(TagState.LEAF);
    assertThat(tags.size(), equalTo(1));
    assertThat(tags.get("A"), empty());
    assertThat(tags.get("B"), empty());
    assertThat(tags.get("C"), empty());
    assertThat(tags.get("D"), containsInAnyOrder(tagD));
  }
}

@Test
public void findWithSingleTagType() {
  Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root");
  Tag tagA = Tags.tag("A", "inputA", rootTag);
  Tag tagB = Tags.tag("B", "inputB", rootTag);
  Tag tagC1 = Tags.tag("C", "inputC1", tagB);
  Tag tagC2 = Tags.tag("C", "inputC2", tagB);
  Tag tagD1 = Tags.tag("D", "inputD1", tagA);
  Tag tagD2 = Tags.tag("D", "inputD2", tagA);
  RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA));
  RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB));
  RuleOutput outputC = new RuleOutput("RuleC", "C", Collections.<ConditionFailure> emptySet(), Arrays.asList(tagC1, tagC2));
  RuleOutput outputD1 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD1));
  RuleOutput outputD2 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD2));
  storage.store(Arrays.asList(outputA, outputB, outputC, outputD1, outputD2));
  Collection<RuleOutput> outputs = storage.findLatestResultsByTagType(new HashSet<>(Arrays.asList("D")));
  assertThat(outputs, hasSize(2));
  assertThat(outputs, containsInAnyOrder(outputD1, outputD2));
}

@Test
public void singleTagTypeSingleInput() throws RuleDefinitionException, SessionException {
  RuleDefinition ruleB = Rules.define(RuleB.class);
  Tag rootTag = Tags.rootTag("input");
  Tag tagA = Tags.tag("A", "input", rootTag);
  RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptyList(), Collections.singletonList(tagA));
  when(outputStorage.findLatestResultsByTagType(Matchers.<Set<String>> anyObject())).thenReturn(Collections.singleton(outputA));
  List<RuleInput> ruleInputs = new ArrayList<>(session.collectInputs(ruleB, outputStorage));
  assertThat(ruleInputs, hasSize(1));
  assertThat(ruleInputs.get(0).getRoot(), equalTo(tagA));
}

  @Test
  public void findWithMultipleTagTypes() {
    Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root");
    Tag tagA = Tags.tag("A", "inputA", rootTag);
    Tag tagB = Tags.tag("B", "inputB", rootTag);
    Tag tagC1 = Tags.tag("C", "inputC1", tagB);
    Tag tagC2 = Tags.tag("C", "inputC2", tagB);
    Tag tagD1 = Tags.tag("D", "inputD1", tagA);
    Tag tagD2 = Tags.tag("D", "inputD2", tagA);
    RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA));
    RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB));
    RuleOutput outputC = new RuleOutput("RuleC", "C", Collections.<ConditionFailure> emptySet(), Arrays.asList(tagC1, tagC2));
    RuleOutput outputD1 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD1));
    RuleOutput outputD2 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD2));
    storage.store(Arrays.asList(outputA, outputB, outputC, outputD1, outputD2));
    Collection<RuleOutput> outputs = storage.findLatestResultsByTagType(new HashSet<>(Arrays.asList("D", "C")));
    assertThat(outputs, hasSize(3));
    assertThat(outputs, containsInAnyOrder(outputD1, outputD2, outputC));
  }
}

@Test
public void storeMultipleWithoutConditionFailures() {
  Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root");
  Tag tagA = Tags.tag("A", "inputA", rootTag);
  Tag tagB = Tags.tag("B", "inputB", rootTag);
  RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA));
  RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB));
  storage.store(Arrays.asList(outputA, outputB));
  assertThat(storage.getAvailableTagTypes(), containsInAnyOrder("A", "B"));
  assertThat(storage.getAllOutputs().keySet(), hasSize(2));
  assertThat(storage.getAllOutputs().keySet(), containsInAnyOrder("A", "B"));
  assertThat(storage.getAllOutputs().get("A"), containsInAnyOrder(outputA));
  assertThat(storage.getAllOutputs().get("B"), containsInAnyOrder(outputB));
  assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(0));
}

Javadoc

Represents the result of a single execution of a RuleDefinition.

Most used methods

<init>
Default constructor.
getConditionFailures
Gets #conditionFailures.
getRuleName
Gets #ruleName.
getTags
Gets #tags.
getEmbeddedTagType
Gets #embeddedTagType.
hasConditionFailures
Convenience method to check if the rule execution failed due to failed conditions.
hasResultTags
Convenience method to check if the rule execution produced result tags.

Popular in Java

Updating database using SQL prepared statement
getSupportFragmentManager (FragmentActivity)
startActivity (Activity)
addToBackStack (FragmentTransaction)
BorderLayout (java.awt)
A border layout lays out a container, arranging and resizing its components to fit in five regions:
Timestamp (java.sql)
A Java representation of the SQL TIMESTAMP type. It provides the capability of representing the SQL
BitSet (java.util)
The BitSet class implements abit array [http://en.wikipedia.org/wiki/Bit_array]. Each element is eit
LinkedList (java.util)
Doubly-linked list implementation of the List and Dequeinterfaces. Implements all optional list oper
TreeMap (java.util)
Walk the nodes of the tree left-to-right or right-to-left. Note that in descending iterations, next
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to
Top PhpStorm plugins

How to useRuleOutput in rocks.inspectit.server.diagnosis.engine.rule

Best Java code snippets using rocks.inspectit.server.diagnosis.engine.rule.RuleOutput (Showing top 20 results out of 315)

How to use
RuleOutput
in
rocks.inspectit.server.diagnosis.engine.rule