@Test public void testDocWithNoTraces() throws IOException { final String json = buildJson(new String[0], new String[0], "test", 0L); Trace trace = decodeString(json); assertEquals(0, trace.getTraceMap().size()); assertEquals(0, trace.getRelationships().size()); }
private static void writeTraces(final Trace trace, final JsonGenerator generator) throws IOException { generator.writeNumberField(JsonTraceCodec.PLAN_ID, trace.getPlanId()); generator.writeStringField(JsonTraceCodec.PLAN_CLASS, trace.getPlanClass()); generator.writeArrayFieldStart(JsonTraceCodec.TRACES); for (Map.Entry<Long, ShallowTrace> entry : trace.getTraceMap().entrySet()) { final ShallowTrace t = entry.getValue(); writeTrace(t, generator); } generator.writeEndArray(); }
public static Trace single(ShallowTrace shallowTrace) { return single(shallowTrace, TraceBuilder.UNKNOWN_PLAN_CLASS, TraceBuilder.UNKNOWN_PLAN_ID); }
for (JsonNode node : resultsArr) { Trace trace = CODEC.decode(node.toString()); TraceBuilder builder = new TraceBuilder(trace.getRelationships().size() + 1, trace.getPlanClass(), trace.getPlanId()); Map<Long, ShallowTraceBuilder> traceMap = new HashMap<>(); trace.getTraceMap().forEach((key, value) -> { ShallowTraceBuilder stb = new ShallowTraceBuilder(value); traceMap.put(key, stb); builder.addShallowTrace(stb); }); for (TraceRelationship rel : trace.getRelationships()) { builder.addRelationship(rel.getRelationhsip(), traceMap.get(rel.getFrom()), traceMap.get(rel.getTo()));
private Optional<ShallowTrace> findTraceByName(Trace trace, String name) { return trace.getTraceMap().values().stream() .filter(shallowTrace -> shallowTrace.getName().contains(name)) .findAny(); }
private Set<TraceRelationship> getRelationships(Trace trace, long id) { Set<TraceRelationship> result = new HashSet<>(); for (TraceRelationship rel : trace.getRelationships()) { if (rel.getFrom() == id || rel.getTo() == id) { result.add(rel); } } return result; }
public static Trace single(ShallowTrace shallowTrace, String planClass, Long planId) { return new Trace(Collections.singletonMap(shallowTrace.getId(), shallowTrace), Collections.emptySet(), planClass, planId); }
private boolean doesTaskTypeExistInTrace(Trace trace, String taskType) { return trace.getTraceMap().values().stream().anyMatch(shallowTrace -> taskType.equals(shallowTrace.getTaskType())); } }
@Test public void testTraceIsAddedBeforeAwaitCompletes() throws InterruptedException { for (int i = 0; i < 100; i++) { final Task<String> innerTask = value("xyz"); final Task<String> task = new BaseTask<String>() { @Override protected Promise<? extends String> run(final Context context) throws Exception { // We kick off a task that won't finish before the containing task // (this task) is finished. context.run(innerTask); return Promises.value("value"); } }; runAndWait("TestTaskToTrace.testTraceIsAddedBeforeAwaitCompletes", task); assertTrue(task.getTrace().getRelationships().size() > 0); } }
public static Trace deserialize(final JsonNode rootNode) throws IOException { try { final Long planId = getLongField(rootNode, JsonTraceCodec.PLAN_ID); final String planClass = getTextField(rootNode, JsonTraceCodec.PLAN_CLASS); final Map<Long, ShallowTrace> traceMap = parseTraces(rootNode); return new Trace(traceMap, parseRelationships(rootNode, traceMap), planClass, planId); } catch (RuntimeException e) { throw new IOException(e); } }
private ShallowTrace findPossiblyFusedTrace(final Task<?> task) { final ShallowTrace main = task.getShallowTrace(); if (main.getName().equals("fused")) { final Trace trace = task.getTrace(); Optional<Long> child = trace.getRelationships().stream() .map(rel -> getChild(rel, main.getId())) .filter(id-> id != null) .findFirst(); if (child.isPresent()) { return trace.getTraceMap().get(child.get()); } } return main; }
protected boolean hasTask(final String name, final Trace trace) { return trace.getTraceMap().values().stream().anyMatch(shallowTrace -> shallowTrace.getName().equals(name)); }
private static void writeTraces(final Trace trace, final JsonGenerator generator) throws IOException { generator.writeNumberField(JsonTraceCodec.PLAN_ID, trace.getPlanId()); generator.writeStringField(JsonTraceCodec.PLAN_CLASS, trace.getPlanClass()); generator.writeArrayFieldStart(JsonTraceCodec.TRACES); for (Map.Entry<Long, ShallowTrace> entry : trace.getTraceMap().entrySet()) { final ShallowTrace t = entry.getValue(); writeTrace(t, generator); } generator.writeEndArray(); }
/** * Populates sets with ids of tasks that have parent and ids of tasks that have potential * parents with number of potential parents. * Validates that task can have only one parent but many potential parents. */ private void assertAndFindParent(Trace trace, Set<Long> tasksWithParent, Map<Long, Integer> tasksWithPotentialParent) { for (TraceRelationship rel : trace.getRelationships()) { if (rel.getRelationhsip() == Relationship.PARENT_OF) { assertFalse(tasksWithParent.contains(rel.getTo())); tasksWithParent.add(rel.getTo()); } else if (rel.getRelationhsip() == Relationship.POTENTIAL_PARENT_OF) { if (!tasksWithPotentialParent.containsKey(rel.getTo())) { tasksWithPotentialParent.put(rel.getTo(), 0); } tasksWithPotentialParent.put(rel.getTo(), tasksWithPotentialParent.get(rel.getTo()) + 1); } } }
@Override public Trace getTrace() { TraceBuilder traceBuilder = getTraceBuilder(); if (traceBuilder != null) { return traceBuilder.build(); } else { return Trace.single(getShallowTrace(), "none", 0L); } }
return new Trace(traceMap, relationships, _planClass, _planId);
@Test public void testAddRelationship() { final ShallowTraceBuilder trace1 = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("task1").setResultType(ResultType.UNFINISHED); final ShallowTraceBuilder trace2 = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("task2").setResultType(ResultType.UNFINISHED); final TraceBuilder builder = new TraceBuilder(1024, "test", 0L); builder.addRelationship(Relationship.SUCCESSOR_OF, trace1, trace2); Trace trace = builder.build(); assertEquals(trace1.build(), trace.getTraceMap().get(trace1.getId())); assertEquals(trace2.build(), trace.getTraceMap().get(trace2.getId())); assertEquals(1, trace.getRelationships().size()); assertTrue(trace.getRelationships() .contains(new TraceRelationship(trace1, trace2, Relationship.SUCCESSOR_OF))); }
private ShallowTrace findBatchTrace(final Task<?> task) { final ShallowTrace main = task.getShallowTrace(); if (main.getName().startsWith("batch(")) { return main; } else { final Trace trace = task.getTrace(); Optional<ShallowTrace> batchTrace = trace.getTraceMap().entrySet().stream() .filter(entry -> entry.getValue().getName().startsWith("batch(")) .findFirst() .map(Map.Entry::getValue); return batchTrace.orElse(null); } } }
private static void writeRelationships(final Trace trace, final JsonGenerator generator) throws IOException { generator.writeArrayFieldStart(JsonTraceCodec.RELATIONSHIPS); for (TraceRelationship rel : trace.getRelationships()) { generator.writeStartObject(); generator.writeStringField(JsonTraceCodec.RELATIONSHIP_RELATIONSHIP, rel.getRelationhsip().name()); generator.writeNumberField(JsonTraceCodec.RELATIONSHIP_FROM, rel.getFrom()); generator.writeNumberField(JsonTraceCodec.RELATIONSHIP_TO, rel.getTo()); generator.writeEndObject(); } generator.writeEndArray(); }
@Test public void testReversibleUnstartedTrace() throws IOException { final ShallowTraceBuilder test = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("test").setResultType(ResultType.UNFINISHED) .setTaskType(TaskType.FUSION.getName()); final Trace trace = Trace.single(test.build(), "test", 0L); assertReversible(trace); }