@Override public <R> R get(final String key) throws IllegalArgumentException { final R r = (R) this.previousMap.get(key); if (null == r) throw Memory.Exceptions.memoryDoesNotExist(key); else if (this.inExecute && !this.memoryKeys.get(key).isBroadcast()) throw Memory.Exceptions.memoryDoesNotExist(key); else return r; }
@Override public void add(final String key, final Object value) { checkKeyValue(key, value); if (!this.inExecute && ("incr".equals(key) || "and".equals(key) || "or".equals(key))) throw Memory.Exceptions.memoryIsCurrentlyImmutable(); else if (!this.inExecute) throw Memory.Exceptions.memoryAddOnlyDuringVertexProgramExecute(key); this.currentMap.compute(key, (k, v) -> null == v ? value : this.memoryKeys.get(key).getReducer().apply(v, value)); }
@Override public void set(final String key, final Object value) { checkKeyValue(key, value); if (this.inExecute) throw Memory.Exceptions.memorySetOnlyDuringVertexProgramSetUpAndTerminate(key); this.currentMap.put(key, value); }
fail("Should only allow Memory.add() during VertexProgram.execute()"); } catch (final Exception e) { validateException(Memory.Exceptions.memorySetOnlyDuringVertexProgramSetUpAndTerminate("a"), e);
fail(); } catch (final Exception e) { validateException(Memory.Exceptions.memoryDoesNotExist("m1"), e); fail(); } catch (final Exception e) { validateException(Memory.Exceptions.memoryDoesNotExist("m3"), e);
@Test @LoadGraphWith(MODERN) public void shouldHaveImmutableComputeResultMemory() throws Exception { final ComputerResult results = graphProvider.getGraphComputer(graph).program(new VertexProgramB()).submit().get(); try { results.memory().set("set", "test"); } catch (Exception ex) { validateException(Memory.Exceptions.memoryIsCurrentlyImmutable(), ex); } try { results.memory().add("incr", 1); } catch (Exception ex) { validateException(Memory.Exceptions.memoryIsCurrentlyImmutable(), ex); } try { results.memory().add("and", true); } catch (Exception ex) { validateException(Memory.Exceptions.memoryIsCurrentlyImmutable(), ex); } try { results.memory().add("or", false); } catch (Exception ex) { validateException(Memory.Exceptions.memoryIsCurrentlyImmutable(), ex); } }
@Test @LoadGraphWith(MODERN) public void shouldHaveConsistentMemoryVertexPropertiesAndExceptions() throws Exception { ComputerResult results = graphProvider.getGraphComputer(graph).program(new VertexProgramF()).submit().get(); assertEquals(1, results.memory().getIteration()); assertEquals(2, results.memory().asMap().size()); assertEquals(2, results.memory().keys().size()); assertTrue(results.memory().keys().contains("a")); assertTrue(results.memory().keys().contains("b")); assertTrue(results.memory().getRuntime() >= 0); assertEquals(12, results.memory().<Integer>get("a").intValue()); // 2 iterations assertEquals(28, results.memory().<Integer>get("b").intValue()); try { results.memory().get("BAD"); fail("Should throw an IllegalArgumentException"); } catch (IllegalArgumentException e) { assertEquals(Memory.Exceptions.memoryDoesNotExist("BAD").getMessage(), e.getMessage()); } assertEquals(Long.valueOf(0), results.graph().traversal().V().count().next()); // persist new/nothing. results.graph().traversal().V().forEachRemaining(v -> { assertTrue(v.property("nameLengthCounter").isPresent()); assertEquals(Integer.valueOf(v.<String>value("name").length() * 2), Integer.valueOf(v.<Integer>value("nameLengthCounter"))); }); }
public static void validateProgramOnComputer(final GraphComputer computer, final VertexProgram vertexProgram) { if (vertexProgram.getMemoryComputeKeys().contains(null)) throw Memory.Exceptions.memoryKeyCanNotBeNull(); if (vertexProgram.getMemoryComputeKeys().contains("")) throw Memory.Exceptions.memoryKeyCanNotBeEmpty(); final GraphComputer.Features graphComputerFeatures = computer.features(); final VertexProgram.Features vertexProgramFeatures = vertexProgram.getFeatures(); for (final Method method : VertexProgram.Features.class.getMethods()) { if (method.getName().startsWith("requires")) { final boolean supports; final boolean requires; try { supports = (boolean) GraphComputer.Features.class.getMethod(method.getName().replace("requires", "supports")).invoke(graphComputerFeatures); requires = (boolean) method.invoke(vertexProgramFeatures); } catch (final Exception e) { throw new IllegalStateException("A reflection exception has occurred: " + e.getMessage(), e); } if (requires && !supports) throw new IllegalStateException("The vertex program can not be executed on the graph computer: " + method.getName()); } } }
@Override public boolean terminate(Memory memory) { assertEquals(Long.valueOf(6 * (memory.getIteration() + 1)), memory.get("a")); assertEquals(Long.valueOf(6), memory.get("b")); assertFalse(memory.get("c")); assertTrue(memory.get("d")); assertFalse(memory.get("e")); assertEquals(memory.getIteration() + 1, memory.<Integer>get("f").intValue()); memory.set("b", 0l); memory.set("e", true); try { memory.add("a", 0l); fail("Should only allow Memory.set() during VertexProgram.terminate()"); } catch (final Exception e) { validateException(Memory.Exceptions.memoryAddOnlyDuringVertexProgramExecute("a"), e); } return memory.getIteration() > 1; }
@Override public boolean terminate(final Memory memory) { try { memory.get("a"); fail("The memory key does not exist and should fail"); } catch (Exception e) { validateException(Memory.Exceptions.memoryDoesNotExist("a"), e); } try { memory.set("a", true); // fail("Setting a memory key that wasn't declared should fail"); } catch (Exception e) { validateException(GraphComputer.Exceptions.providedKeyIsNotAMemoryComputeKey("a"), e); } return true; }
@Override public <R> R get(final String key) throws IllegalArgumentException { if (!this.memoryComputeKeys.containsKey(key)) { throw Memory.Exceptions.memoryDoesNotExist(key); } if (this.inExecute && !this.memoryComputeKeys.get(key).isBroadcast()) { throw Memory.Exceptions.memoryDoesNotExist(key); } final ObjectWritable<R> r = (ObjectWritable<R>) (this.inExecute ? this.broadcast.value().get(key) : this.sparkMemory.get(key).value()); if (null == r || r.isEmpty()) { throw Memory.Exceptions.memoryDoesNotExist(key); } else { return r.get(); } }
@Override public void setup(final Memory memory) { try { memory.get("a"); fail("The memory key does not exist and should fail"); } catch (Exception e) { validateException(Memory.Exceptions.memoryDoesNotExist("a"), e); } try { memory.set("a", true); fail("Setting a memory key that wasn't declared should fail"); } catch (Exception e) { validateException(GraphComputer.Exceptions.providedKeyIsNotAMemoryComputeKey("a"), e); } }
@Override public void setup(final Memory memory) { memory.set("a", 0l); memory.set("b", 0l); memory.set("c", true); memory.set("d", false); memory.set("e", true); memory.set("f", memory.getIteration()); try { memory.add("a", 0l); fail("Should only allow Memory.set() during VertexProgram.setup()"); } catch (final Exception e) { validateException(Memory.Exceptions.memoryAddOnlyDuringVertexProgramExecute("a"), e); } }
@Override public void execute(final Vertex vertex, final Messenger messenger, final Memory memory) { try { memory.get("a"); fail("The memory key does not exist and should fail"); } catch (Exception e) { validateException(Memory.Exceptions.memoryDoesNotExist("a"), e); } try { memory.add("a", true); fail("Setting a memory key that wasn't declared should fail"); } catch (Exception e) { validateException(GraphComputer.Exceptions.providedKeyIsNotAMemoryComputeKey("a"), e); } }
@Override public <R> R get(final String key) throws IllegalArgumentException { throw Memory.Exceptions.memoryDoesNotExist(key); }
@Override public void set(final String key, final Object value) { throw Memory.Exceptions.memoryIsCurrentlyImmutable(); }
@Override public void setRuntime(final long runtime) { throw Memory.Exceptions.memoryIsCurrentlyImmutable(); }
@Override public void incrIteration() { throw Memory.Exceptions.memoryIsCurrentlyImmutable(); }
@Override public void add(final String key, final Object value) throws IllegalArgumentException, IllegalStateException { throw Memory.Exceptions.memoryIsCurrentlyImmutable(); }
@Override public void setIteration(final int iteration) { throw Memory.Exceptions.memoryIsCurrentlyImmutable(); }