@Override
public Set<AlarmReceiver> getReceivers(Transport transport) {
Set<AlarmReceiver> r = Sets.newHashSet();
for (AlarmReceiver receiver : receivers) {
String address = receiver.getAddress(transport);
if (address != null && !address.isEmpty()) {
r.add(receiver);
}
}
return r;
}
@SuppressWarnings("unchecked")
public <T, I> T getImplementationClass( //
QueryClassLoader classLoader, //
TemplateClassDefinition<T> templateDefinition, //
String entireClass, //
String materializedClassName)
throws ClassTransformationException {
final ClassSet set =
new ClassSet(null, templateDefinition.getTemplateClassName(), materializedClassName);
try {
final byte[][] implementationClasses =
classLoader.getClassByteCode(set.generated.clazz, entireClass);
Map<String, ClassNode> classesToMerge = Maps.newHashMap();
for (byte[] clazz : implementationClasses) {
ClassNode node = getClassNodeFromByteCode(clazz);
classesToMerge.put(node.name, node);
}
LinkedList<ClassSet> names = Lists.newLinkedList();
Set<ClassSet> namesCompleted = Sets.newHashSet();
names.add(set);
while (!names.isEmpty()) {
final ClassSet nextSet = names.removeFirst();
if (namesCompleted.contains(nextSet)) continue;
final ClassNames nextPrecompiled = nextSet.precompiled;
final byte[] precompiledBytes =
byteCodeLoader.getClassByteCodeFromPath(nextPrecompiled.clazz);
ClassNames nextGenerated = nextSet.generated;
ClassNode generatedNode = classesToMerge.get(nextGenerated.slash);
MergedClassResult result =
MergeAdapter.getMergedClass(nextSet, precompiledBytes, generatedNode);
for (String s : result.innerClasses) {
s = s.replace(FileUtils.separatorChar, '.');
names.add(nextSet.getChild(s));
}
classLoader.injectByteCode(nextGenerated.dot, result.bytes);
namesCompleted.add(nextSet);
}
// logger.debug(String.format("[Compile Time] Janino: %dms, Bytecode load and parse:
// %dms, Class Merge: %dms, Subclass remap and load: %dms.",
// t1.elapsed(TimeUnit.MILLISECONDS), t2.elapsed(TimeUnit.MILLISECONDS),
// t3.elapsed(TimeUnit.MILLISECONDS), t4.elapsed(TimeUnit.MILLISECONDS)));
Class<?> c = classLoader.findClass(set.generated.dot);
if (templateDefinition.getExternalInterface().isAssignableFrom(c)) {
return (T) c.newInstance();
} else {
throw new ClassTransformationException(
"The requested class did not implement the expected interface.");
}
} catch (CompileException
| IOException
| ClassNotFoundException
| InstantiationException
| IllegalAccessException e) {
throw new ClassTransformationException(
String.format("Failure generating transformation classes for value: \n %s", entireClass),
e);
}
}
@Test
public void createWithVisibilityFluo() throws Exception {
final String sparql =
"SELECT ?customer ?worker ?city "
+ "{ "
+ "?customer <http://talksTo> ?worker. "
+ "?worker <http://livesIn> ?city. "
+ "?worker <http://worksAt> <http://Chipotle>. "
+ "}";
// Triples that will be streamed into Fluo after the PCJ has been created.
final Map<RyaStatement, String> streamedTriples = new HashMap<>();
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Alice", "http://talksTo", "http://Bob"), "A&B");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Bob", "http://livesIn", "http://London"), "A");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Bob", "http://worksAt", "http://Chipotle"), "B");
addStatementVisibilityEntry(
streamedTriples,
makeRyaStatement("http://Alice", "http://talksTo", "http://Charlie"),
"B&C");
addStatementVisibilityEntry(
streamedTriples,
makeRyaStatement("http://Charlie", "http://livesIn", "http://London"),
"B");
addStatementVisibilityEntry(
streamedTriples,
makeRyaStatement("http://Charlie", "http://worksAt", "http://Chipotle"),
"C");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Alice", "http://talksTo", "http://David"), "C&D");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://David", "http://livesIn", "http://London"), "C");
addStatementVisibilityEntry(
streamedTriples,
makeRyaStatement("http://David", "http://worksAt", "http://Chipotle"),
"D");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Alice", "http://talksTo", "http://Eve"), "D&E");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Eve", "http://livesIn", "http://Leeds"), "D");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Eve", "http://worksAt", "http://Chipotle"), "E");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Frank", "http://talksTo", "http://Alice"), "");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Frank", "http://livesIn", "http://London"), "");
addStatementVisibilityEntry(
streamedTriples, makeRyaStatement("http://Frank", "http://worksAt", "http://Chipotle"), "");
// Create the PCJ Table in Accumulo.
final PrecomputedJoinStorage rootStorage =
new AccumuloPcjStorage(accumuloConn, RYA_INSTANCE_NAME);
final String pcjId = rootStorage.createPcj(sparql);
// Create the PCJ in Fluo.
new CreatePcj()
.withRyaIntegration(pcjId, rootStorage, fluoClient, accumuloConn, RYA_INSTANCE_NAME);
// Stream the data into Fluo.
for (final RyaStatement statement : streamedTriples.keySet()) {
final Optional<String> visibility = Optional.of(streamedTriples.get(statement));
new InsertTriples().insert(fluoClient, statement, visibility);
}
// Fetch the exported results from Accumulo once the observers finish working.
fluo.waitForObservers();
setupTestUsers(accumuloConn, RYA_INSTANCE_NAME, pcjId);
// Verify ABCDE using root.
final Set<BindingSet> rootResults = toSet(rootStorage.listResults(pcjId));
final Set<BindingSet> rootExpected = Sets.newHashSet();
rootExpected.add(
makeBindingSet(
new BindingImpl("customer", new URIImpl("http://Alice")),
new BindingImpl("worker", new URIImpl("http://Bob")),
new BindingImpl("city", new URIImpl("http://London"))));
rootExpected.add(
makeBindingSet(
new BindingImpl("customer", new URIImpl("http://Alice")),
new BindingImpl("worker", new URIImpl("http://Charlie")),
new BindingImpl("city", new URIImpl("http://London"))));
rootExpected.add(
makeBindingSet(
new BindingImpl("customer", new URIImpl("http://Alice")),
new BindingImpl("worker", new URIImpl("http://Eve")),
new BindingImpl("city", new URIImpl("http://Leeds"))));
rootExpected.add(
makeBindingSet(
new BindingImpl("customer", new URIImpl("http://Alice")),
new BindingImpl("worker", new URIImpl("http://David")),
new BindingImpl("city", new URIImpl("http://London"))));
assertEquals(rootExpected, rootResults);
// Verify AB
final Connector abConn = cluster.getConnector("abUser", "password");
final PrecomputedJoinStorage abStorage = new AccumuloPcjStorage(abConn, RYA_INSTANCE_NAME);
final Set<BindingSet> abResults = toSet(abStorage.listResults(pcjId));
final Set<BindingSet> abExpected = Sets.newHashSet();
abExpected.add(
makeBindingSet(
new BindingImpl("customer", new URIImpl("http://Alice")),
new BindingImpl("worker", new URIImpl("http://Bob")),
new BindingImpl("city", new URIImpl("http://London"))));
assertEquals(abExpected, abResults);
// Verify ABC
final Connector abcConn = cluster.getConnector("abcUser", "password");
final PrecomputedJoinStorage abcStorage = new AccumuloPcjStorage(abcConn, RYA_INSTANCE_NAME);
final Set<BindingSet> abcResults = toSet(abcStorage.listResults(pcjId));
final Set<BindingSet> abcExpected = Sets.newHashSet();
abcExpected.add(
makeBindingSet(
new BindingImpl("customer", new URIImpl("http://Alice")),
new BindingImpl("worker", new URIImpl("http://Bob")),
new BindingImpl("city", new URIImpl("http://London"))));
abcExpected.add(
makeBindingSet(
new BindingImpl("customer", new URIImpl("http://Alice")),
new BindingImpl("worker", new URIImpl("http://Charlie")),
new BindingImpl("city", new URIImpl("http://London"))));
assertEquals(abcExpected, abcResults);
// Verify ADE
final Connector adeConn = cluster.getConnector("adeUser", "password");
final PrecomputedJoinStorage adeStorage = new AccumuloPcjStorage(adeConn, RYA_INSTANCE_NAME);
final Set<BindingSet> adeResults = toSet(adeStorage.listResults(pcjId));
final Set<BindingSet> adeExpected = Sets.newHashSet();
adeExpected.add(
makeBindingSet(
new BindingImpl("customer", new URIImpl("http://Alice")),
new BindingImpl("worker", new URIImpl("http://Eve")),
new BindingImpl("city", new URIImpl("http://Leeds"))));
assertEquals(adeExpected, adeResults);
// Verify no auths.
final Connector noAuthConn = cluster.getConnector("noAuth", "password");
final PrecomputedJoinStorage noAuthStorage =
new AccumuloPcjStorage(noAuthConn, RYA_INSTANCE_NAME);
final Set<BindingSet> noAuthResults = toSet(noAuthStorage.listResults(pcjId));
assertTrue(noAuthResults.isEmpty());
}
@Override
public ScoreboardContent computeScoreboardContent(
Contest contest,
ScoreboardState state,
List<ProgrammingSubmission> submissions,
Map<String, Date> contestantStartTimes,
Map<String, URL> userJidToImageMap) {
ICPCContestStyleConfig icpcStyleConfig = (ICPCContestStyleConfig) contest.getStyleConfig();
ScoreboardEntryComparator<ICPCScoreboardEntry> comparator = new ICPCScoreboardEntryComparator();
Map<String, Map<String, Integer>> attemptsMap = Maps.newHashMap();
Map<String, Map<String, Long>> penaltyMap = Maps.newHashMap();
Map<String, Map<String, Integer>> problemStateMap = Maps.newHashMap();
Map<String, Long> lastAcceptedPenaltyMap = Maps.newHashMap();
Set<String> acceptedProblemJids = Sets.newHashSet();
for (String contestantJid : state.getContestantJids()) {
attemptsMap.put(contestantJid, Maps.newHashMap());
penaltyMap.put(contestantJid, Maps.newHashMap());
problemStateMap.put(contestantJid, Maps.newHashMap());
for (String problemJid : state.getProblemJids()) {
attemptsMap.get(contestantJid).put(problemJid, 0);
penaltyMap.get(contestantJid).put(problemJid, 0L);
lastAcceptedPenaltyMap.put(contestantJid, 0L);
problemStateMap
.get(contestantJid)
.put(problemJid, ICPCScoreboardEntry.State.NOT_ACCEPTED.ordinal());
}
}
for (ProgrammingSubmission submission : submissions) {
String contestantJid = submission.getAuthorJid();
String problemJid = submission.getProblemJid();
if (!attemptsMap.containsKey(contestantJid)) {
continue;
}
if (!attemptsMap.get(contestantJid).containsKey(problemJid)) {
continue;
}
if (problemStateMap.get(contestantJid).get(problemJid)
!= ICPCScoreboardEntry.State.NOT_ACCEPTED.ordinal()) {
continue;
}
Verdict verdict = submission.getLatestVerdict();
if (verdict.getCode().equals("?")) {
continue;
}
int attempts = attemptsMap.get(contestantJid).get(problemJid);
attemptsMap.get(contestantJid).put(problemJid, attempts + 1);
long penaltyInMilliseconds =
computeSubmissionPenaltyInMilliseconds(
contest, contestantStartTimes.get(contestantJid), submission.getTime());
penaltyMap.get(contestantJid).put(problemJid, convertPenaltyToMinutes(penaltyInMilliseconds));
if (verdict.getCode().equals("AC")) {
if (acceptedProblemJids.contains(problemJid)) {
problemStateMap
.get(contestantJid)
.put(problemJid, ICPCScoreboardEntry.State.ACCEPTED.ordinal());
} else {
problemStateMap
.get(contestantJid)
.put(problemJid, ICPCScoreboardEntry.State.FIRST_ACCEPTED.ordinal());
acceptedProblemJids.add(problemJid);
}
lastAcceptedPenaltyMap.put(contestantJid, penaltyInMilliseconds);
}
}
List<ICPCScoreboardEntry> entries = Lists.newArrayList();
for (String contestantJid : state.getContestantJids()) {
ICPCScoreboardEntry entry = new ICPCScoreboardEntry();
entry.contestantJid = contestantJid;
entry.imageURL = userJidToImageMap.get(contestantJid);
for (String problemJid : state.getProblemJids()) {
int attempts = attemptsMap.get(contestantJid).get(problemJid);
long penalty = penaltyMap.get(contestantJid).get(problemJid);
long lastAcceptedPenalty = lastAcceptedPenaltyMap.get(contestantJid);
int problemState = problemStateMap.get(contestantJid).get(problemJid);
entry.attemptsList.add(attempts);
entry.penaltyList.add(penalty);
entry.lastAcceptedPenalty = lastAcceptedPenalty;
entry.problemStateList.add(problemState);
if (problemState != ICPCScoreboardEntry.State.NOT_ACCEPTED.ordinal()) {
entry.totalAccepted++;
entry.totalPenalties +=
icpcStyleConfig.getWrongSubmissionPenalty() * (attempts - 1) + penalty;
}
}
entries.add(entry);
}
sortEntriesAndAssignRanks(comparator, entries);
return new ICPCScoreboardContent(entries);
}
