public static boolean isFailure(OkEvent event) { switch (event.function()) { case RequestType.UNLOCK: return event.value().equals(OkEvent.UNLOCK_FAILURE); case RequestType.LOCK: return event.value().equals(OkEvent.LOCK_FAILURE); case RequestType.REFRESH: return event.value().equals(OkEvent.REFRESH_FAILURE); case RequestType.TIMESTAMP: return event.value().equals(OkEvent.TIMESTAMP_FAILURE); default: return false; } }
@Override public void visit(OkEvent event) { int process = event.process(); if (latestEventPerProcess.containsKey(process)) { OkEvent previousEvent = latestEventPerProcess.get(process); long previousTimestamp = Long.parseLong(previousEvent.value()); long timestamp = Long.parseLong(event.value()); if (timestamp <= previousTimestamp) { errors.add(previousEvent); errors.add(event); } } latestEventPerProcess.put(process, event); }
int process = event.process(); InvokeEvent invokeEvent = pendingForProcess.get(process); switch (event.function()) { case RequestType.UNLOCK: if (lastHeldLock.containsKey(process)) { long lastLockTime = lastHeldLock.get(process).time(); if (lastLockTime < invokeEvent.time()) { locksHeld.add(Range.open(lastLockTime, invokeEvent.time()));
@Override public void visit(OkEvent event) { if (awaitingInvokeOkCycle && processesPendingReads.contains(event.process())) { awaitingInvokeOkCycle = false; } }
@Override public void visit(OkEvent event) { String value = event.value(); if (valuesAlreadySeen.containsKey(value)) { OkEvent previousEvent = valuesAlreadySeen.get(value); errors.add(previousEvent); errors.add(event); } valuesAlreadySeen.put(value, event); }
private boolean intervalCovered(InvokeEvent invokeEvent, OkEvent okEvent) { Range<Long> interval = Range.closed(invokeEvent.time(), okEvent.time()); return locksHeld.encloses(interval); }
int process = event.process(); InvokeEvent invokeEvent = pendingForProcess.get(process); switch (event.function()) { + "(last known time the lock was held by {})", invokeEvent.function(), invokeEvent.value(), invokeEvent.process(), invokeEvent.time(), event.time(), lastLockTime, invokeEvent.time(), invokeEvent.process()); errors.add(invokeEvent);
private void addEventsToErrors(OkEvent event, Integer process) { Event previousEvent; if (lastOkEvent.containsKey(process)) { previousEvent = lastOkEvent.get(process); } else { previousEvent = pendingForProcess.get(event.process()); } errors.add(previousEvent); errors.add(event); }
private void validateTimestampHigherThanReadsCompletedBeforeInvoke(InvokeEvent invoke, OkEvent event) { OkEvent lastAcknowledgedRead = lastAcknowledgedReadBefore(invoke.time()); if (lastAcknowledgedRead != null) { long timestamp = Long.parseLong(event.value()); long lastAcknowledgedTimestamp = Long.parseLong(lastAcknowledgedRead.value()); if (lastAcknowledgedTimestamp >= timestamp) { errors.add(lastAcknowledgedRead); errors.add(invoke); errors.add(event); } } }
private void verifyLockCorrectness() { for (Pair<InvokeEvent, OkEvent> eventPair : locksAtSomePoint) { InvokeEvent invokeEvent = eventPair.getLhSide(); OkEvent okEvent = eventPair.getRhSide(); if (intervalCovered(invokeEvent, okEvent)) { log.error("Lock {} granted to process {} between {} and {}, but lock was already held by " + "another process.", lockName, invokeEvent.process(), invokeEvent.time(), okEvent.time()); errors.add(invokeEvent); errors.add(okEvent); } } }
@Override public void visit(OkEvent event) { int process = event.process(); InvokeEvent invoke = pendingReadForProcess.get(process); if (invoke != null) { validateTimestampHigherThanReadsCompletedBeforeInvoke(invoke, event); } pendingReadForProcess.remove(process); acknowledgedReadsOverTime.add(event); }