public List<ViolationsEntry> violationsChartData(long projectId) { List<ViolationsEntry> violationsEntryList = new ArrayList<ViolationsEntry>(); for (Violation violation : violationRepository.findByProjectId(projectId)) { violationsEntryList.add(new ViolationsEntry(violation.getDateTime())); } return violationsEntryList; }
public List<ViolationsEntry> violationsChartData() { List<ViolationsEntry> violationsEntryList = new ArrayList<ViolationsEntry>(); for (Violation violation : violationRepository.findAll()) { violationsEntryList.add(new ViolationsEntry(violation.getDateTime())); } return violationsEntryList; }
public static Violation getViolation(String description) { if (violationsList == null) return null; Violation matchViolation = new Violation(); for (Violation violation : violationsList) { if (description.equals(violation.getDescription())) { matchViolation = violation; } } return matchViolation; }
/** * @param plan * @return a list of activities and other plan elements that have violations. */ public static Set<EPlanElement> getPlanElementsWithViolations(EPlan plan) { Set<EPlanElement> result = new HashSet(); if (noDomainFor(plan)) { return Collections.EMPTY_SET; } List<ViolationTracker> trackers = PlanAdvisorMember.get(plan).getViolationTrackers(); for (ViolationTracker tracker : trackers) { Violation violation = tracker.getViolation(); if (violation.isCurrentlyViolated()) { result.addAll(violation.getElements()); } } return result; }
@Override public void process(IPatternMatch match) { Map<String, Object> keyObjectMap = constraint.getSpecification().getKeyObjects(match); if (!keyObjectMap.isEmpty()) { ViolationKey key = constraint.getViolationKey(match); Violation violation = constraint.getViolation(key); if (violation == null) { violation = new Violation(); violation.setConstraint(constraint); violation.setKeyObjects(constraint.getSpecification().getKeyObjects(match)); violation.setMessage( IncQueryRuntimeHelper.getMessage( match, constraint.getSpecification().getMessageFormat())); constraint.addViolation(key, violation); constraint.notifyListenersViolationAppeared(violation); } if (violation.addMatch(match)) { violation.notifyListenersViolationEntryAppeared(match); } } else { logger.error("Error getting Violation key objects!"); } }
boolean checkConst(Record rec, ThreadInfo ti, FieldInfo fi, Instruction insn) { if (checkConst) { AnnotationInfo ai = insn.getMethodInfo().getAnnotation("gov.nasa.jpf.Const"); if (ai != null) { violation = new Violation(rec, ti, fi, insn); violation.setConstErrorMessage(); ti.breakTransition(); return false; } } return true; }
boolean checkShared(Record rec, ThreadInfo ti, InfoObject use, Instruction insn) { if (checkShared) { AnnotationInfo ai = rec.ei.getClassInfo().getAnnotation("gov.nasa.jpf.NonShared"); if (ai != null && ti != rec.tiCreate) { violation = new Violation(rec, ti, use, insn); violation.setSharedErrorMessage(); ti.breakTransition(); return false; } } return true; }
/** * Add a new Violation to the list of violations found by this visitor. Only add the violation if * the node lineNumber >= 0. * * @param node - the Groovy AST Node * @param message - the message for the violation; defaults to null */ protected void addViolation(MethodCallExpression node, String message) { if (node.getLineNumber() >= 0) { int lineNumber = AstUtil.findFirstNonAnnotationLine(node, sourceCode); String sourceLine = sourceCode.line(AstUtil.findFirstNonAnnotationLine(node, sourceCode) - 1); Violation violation = new Violation(); violation.setRule(rule); violation.setLineNumber(lineNumber); violation.setSourceLine(sourceLine); if (currentClassNode != null) { violation.setMessage( String.format("Violation in class %s. %s", currentClassNode.getName(), message)); } else { violation.setMessage(message); } violations.add(violation); } }
@Override public Violation build() { try { Violation record = new Violation(); record.businessId = fieldSetFlags()[0] ? this.businessId : (java.lang.Integer) defaultValue(fields()[0]); record.date = fieldSetFlags()[1] ? this.date : (java.lang.CharSequence) defaultValue(fields()[1]); record.violationTypeID = fieldSetFlags()[2] ? this.violationTypeID : (java.lang.Long) defaultValue(fields()[2]); record.riskCategory = fieldSetFlags()[3] ? this.riskCategory : (java.lang.CharSequence) defaultValue(fields()[3]); record.description = fieldSetFlags()[4] ? this.description : (java.lang.CharSequence) defaultValue(fields()[4]); return record; } catch (Exception e) { throw new org.apache.avro.AvroRuntimeException(e); } }
/** * reads the violations from the given xml file * * <p>xml file structure is as follows * * <p><violations> <violation priority="1"> <vtext>.document</vtext> </violation> * ............................ </violations> * * @param violationsFilePath * @return * @throws ParserConfigurationException * @throws SAXException * @throws IOException */ public static List<Violation> getViolations(File violationsFilePath) throws ParserConfigurationException, SAXException, IOException { List<Violation> violations = new ArrayList<Violation>(); DocumentBuilder docBuilder = dbf.newDocumentBuilder(); Document doc = docBuilder.parse(violationsFilePath); NodeList violationsNodeList = doc.getElementsByTagName("violation"); int noOfNodes = violationsNodeList.getLength(); for (int i = 0; i < noOfNodes; i++) { Violation violation = new Violation(); Node violationNode = violationsNodeList.item(i); String priority = ((Element) violationNode).getAttribute("priority"); if (priority == null || priority.isEmpty()) priority = "1"; violation.setPriority(priority); String type = ((Element) violationNode).getAttribute("type"); if (type != null && !type.isEmpty()) violation.setViolationType(type); String filetypes = ((Element) violationNode).getAttribute("filetypes"); if (filetypes != null && !filetypes.isEmpty()) { for (String filetype : filetypes.split(",")) { violation.addFileType(filetype); } } Node vTextNode = ((Element) violationNode).getElementsByTagName("vtext").item(0); if (vTextNode != null) { String vText = vTextNode.getFirstChild().getNodeValue(); violation.setViolationText(vText); } Node vRegexpNode = ((Element) violationNode).getElementsByTagName("regexp").item(0); if (vRegexpNode != null) { Node rNode = vRegexpNode.getFirstChild(); if (rNode != null) { String regexp = rNode.getNodeValue(); violation.setRegularExpression(regexp); } } Node vdescriptionNode = ((Element) violationNode).getElementsByTagName("description").item(0); if (vdescriptionNode != null) { Node dNode = vdescriptionNode.getFirstChild(); if (dNode != null) { String description = dNode.getNodeValue(); violation.setDescription(description); } } Node vSuggestionNode = ((Element) violationNode).getElementsByTagName("suggestion").item(0); if (vSuggestionNode != null) { Node sNode = vSuggestionNode.getFirstChild(); if (sNode != null) { String suggestion = sNode.getNodeValue(); violation.setSuggestion(suggestion); } } Node vExceptionsNode = ((Element) violationNode).getElementsByTagName("exceptions").item(0); if (vExceptionsNode != null) { NodeList regexExceptions = ((Element) vExceptionsNode).getElementsByTagName("regexp"); for (int j = 0; j < regexExceptions.getLength(); j++) { Node regexExceptionNode = regexExceptions.item(j).getFirstChild(); if (regexExceptionNode != null) { String regexException = regexExceptionNode.getNodeValue(); violation.addRegexException(regexException); } } NodeList textExceptions = ((Element) vExceptionsNode).getElementsByTagName("vtext"); for (int j = 0; j < textExceptions.getLength(); j++) { Node textExceptionNode = textExceptions.item(j).getFirstChild(); if (textExceptionNode != null) { String regexException = textExceptionNode.getNodeValue(); violation.addTextException(regexException); } } } Node vExclusionlistNode = ((Element) violationNode).getElementsByTagName("exclusionlist").item(0); if (vExclusionlistNode != null) { NodeList excludeList = ((Element) vExclusionlistNode).getElementsByTagName("exclude"); for (int j = 0; j < excludeList.getLength(); j++) { Node excludeListNode = excludeList.item(j).getFirstChild(); if (excludeListNode != null) { String excludeListName = excludeListNode.getNodeValue(); violation.addExclusionlist(excludeListName); } } } violations.add(violation); } violationsList = violations; return violations; }
private void materialiseMultiStage( MultiStageUpperProgram program, Treatment4Classification treatment, GapByStore4ID_registerInfoAboutInstantiationIndividualsOnly gap) { String programName = "multi-stage upper program"; Logger_MORe.logInfo(name + " store is materialising " + programName + " ..."); Timer t = new Timer(); long tripleCountBeforeMat = 0; program.saveDatalogRules(Utility_PAGOdA.TempDirectory + "/multi_datalog.dlog"); Collection<Violation> violations = null; int iteration = 0; Timer subTimer = new Timer(); boolean incrementally = false; try { while (true) { long oldTripleCount = store.getTriplesCount(); subTimer.reset(); Logger_MORe.logInfo("Iteration " + ++iteration + ": "); incrementally = (iteration != 1); if (incrementally) gap.compileFromFile(null); else { tripleCountBeforeMat = oldTripleCount; gap.compileFromFile(new File(Utility_PAGOdA.TempDirectory + "/multi_datalog.dlog")); } // Utility.printStoreToFile(store, "multistageMaterialisationIter"+iteration); // Utility.printPredicatesSummaryOfStoreToFile(store, // "multistageMaterialisationIter"+iteration); Utility.printAllTriples(getDataStore()); gap .registerGapTuples(); // PAGOdA does not add the gap when doing multistage because the // multistage store cannot be used for tracking, but we want to // register // which instantiation individuals have a gap and which don't to detect classes that may be // fully classified at this point. // this is an alternative to addGapBackTo that registers information about which // instantiation individuals have a gap but // doesn't add gap tuples to the store. long tripleCount = store.getTriplesCount(); Logger_MORe.logDebug( name + " store after materialising datalog-rules: " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)"); Logger_MORe.logDebug("Time to materialise datalog-rules: " + subTimer.duration()); subTimer.reset(); if ((violations = program.isIntegrated(this, incrementally)) == null || violations.size() == 0) { store.clearRulesAndMakeFactsExplicit(); Logger_MORe.logDebug( name + " store after materialising " + programName + ": " + tripleCount + " (" + (tripleCount - tripleCountBeforeMat) + " new)"); Logger_MORe.logInfo( name + " store is DONE for multi-stage materialising in " + t.duration() + " seconds."); return; } Logger_MORe.logDebug("Time to detect violations: " + subTimer.duration()); store.makeFactsExplicit(); subTimer.reset(); oldTripleCount = store.getTriplesCount(); for (Violation v : violations) { Timer localTimer = new Timer(); int number = v.size(); long vOldCounter = store.getTriplesCount(); treatment.makeSatisfied(v, gap); Logger_MORe.logDebug( "Time to make the constraint being satisfied: " + localTimer.duration() + " " + number + " tuples for " + v.getConstraint()); Logger_MORe.logDebug( "tuple number: " + v.size() + " before: " + vOldCounter + " after: " + store.getTriplesCount() + " (" + (store.getTriplesCount() - vOldCounter) + " new) ."); } Logger_MORe.logDebug( name + " store after adding facts for violations: " + (tripleCount = store.getTriplesCount()) + " (" + (tripleCount - oldTripleCount) + " new)"); Logger_MORe.logDebug("Time to add triples for violations: " + subTimer.duration()); } } catch (JRDFStoreException e) { e.printStackTrace(); } }
protected Set<?>[] materialise( MultiStageUpperProgram4Classification program, Treatment treatment, boolean registerPredicatesWithGap) { // based on materialise(MultiStageUpperProgram, Treatment, GapByStore4ID) Set<?>[] ret = new Set<?>[3]; if (registerPredicatesWithGap) { ret[0] = new HashSet<OWLClass>(); // classes with candidate subsumers ret[1] = new HashSet<String>(); // potentiallyUnsatClasses ret[2] = new HashSet<String>(); // candidate subsumers // do I even need to store these? } String programName = "multi-stage upper program"; Logger_MORe.logInfo(name + " store is materialising " + programName + " ..."); Timer t = new Timer(); long tripleCountBeforeMat = 0; Collection<Violation> violations = null; int iteration = 0; Timer subTimer = new Timer(); boolean incrementally = false; TupleIterator iter = null; try { while (true) { long oldTripleCount = store.getTriplesCount(); subTimer.reset(); Logger_MORe.logInfo("Iteration " + ++iteration + ": "); incrementally = (iteration != 1); if (incrementally) store.setNumberOfThreads(1); else { tripleCountBeforeMat = oldTripleCount; store.importFiles( new File[] {new File(program.getOutputPath())}, new Prefixes(), UpdateType.Add, true); } store.applyReasoning(incrementally); store.setNumberOfThreads(matNoOfThreads); if (registerPredicatesWithGap) { // here we are basically imitating GapByStore4ID, can't we just add the relevant methods // to that class and use it class here? try { iter = internal_evaluateAgainstIDBs( "select ?x ?z where { ?x " + MyPrefixes.PAGOdAPrefixes.expandText("rdf:type") + " ?z . }"); for (long multi = iter.open(); multi != 0; multi = iter.getNext()) { OWLClass c = indManager.getClass4Individual( RDFoxTripleManager.getRawTerm(iter.getResource(0))); if (c != null) { String s = RDFoxTripleManager.getRawTerm(iter.getResource(1)); if (s.equals(MyPrefixes.PAGOdAPrefixes.expandText("owl:Nothing"))) { ((Set<String>) ret[1]).add(RDFoxTripleManager.getRawTerm(iter.getResource(0))); ((Set<OWLClass>) ret[0]).add(c); } else { ((Set<OWLClass>) ret[0]).add(c); ((Set<String>) ret[2]).add(RDFoxTripleManager.getRawTerm(iter.getResource(1))); } } } } catch (JRDFStoreException e) { e.printStackTrace(); if (iter != null) iter.dispose(); } finally { if (iter != null) iter.dispose(); } } long tripleCount = store.getTriplesCount(); Logger_MORe.logDebug( name + " store after materialising datalog-rules: " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)"); Logger_MORe.logDebug("Time to materialise datalog-rules: " + subTimer.duration()); subTimer.reset(); // TODO revise this chunk to make sure inconsistencies do not make us stop materialising // FIXME if ((violations = program.isIntegrated(this, incrementally)) == null || violations.size() == 0) { store.clearRulesAndMakeFactsExplicit(); Logger_MORe.logDebug( name + " store after materialising " + programName + ": " + tripleCount + " (" + (tripleCount - tripleCountBeforeMat) + " new)"); Logger_MORe.logInfo( name + " store is DONE for multi-stage materialising in " + t.duration() + " seconds."); return ret; // isValid() ? 1 : 0; } Logger_MORe.logDebug("Time to detect violations: " + subTimer.duration()); store.makeFactsExplicit(); // first.printAllTriples(getDataStore()); subTimer.reset(); oldTripleCount = store.getTriplesCount(); for (Violation v : violations) { Timer localTimer = new Timer(); int number = v.size(); long vOldCounter = store.getTriplesCount(); if (registerPredicatesWithGap) { for (AnswerTuple tuple : ((Treatment4Classification) treatment).makeSatisfiedAndReturnAddedTuples(v)) { OWLClass c = indManager.getClass4Individual(tuple.getRawTerm(0)); if (c != null) { String s = tuple.getRawTerm(1); if (s.equals(MyPrefixes.PAGOdAPrefixes.expandText("owl:Nothing"))) { ((Set<String>) ret[1]).add(tuple.getRawTerm(0)); ((Set<OWLClass>) ret[0]).add(c); } else { ((Set<OWLClass>) ret[0]).add(c); ((Set<String>) ret[2]).add(tuple.getRawTerm(1)); } } } } else { if (!treatment.makeSatisfied(v)) { // validMaterialisation = false; // Utility.logInfo(name + " store FAILED for multi-stage materialisation in " + // t.duration() + " seconds."); Logger_MORe.logInfo( name + " store could not make violation satisfied for multi-stage materialisation, but we'll keep going!."); // return 0; } } Logger_MORe.logDebug( "Time to make the constraint being satisfied: " + localTimer.duration() + " " + number + " tuples for " + v.getConstraint()); Logger_MORe.logDebug( "tuple number: " + v.size() + " before: " + vOldCounter + " after: " + store.getTriplesCount() + " (" + (store.getTriplesCount() - vOldCounter) + " new) ."); } Logger_MORe.logDebug( name + " store after adding facts for violations: " + (tripleCount = store.getTriplesCount()) + " (" + (tripleCount - oldTripleCount) + " new)"); Logger_MORe.logDebug("Time to add triples for violations: " + subTimer.duration()); } } catch (JRDFStoreException e) { e.printStackTrace(); } return ret; }
protected void exception(String path, String detail, Throwable t) { Violation violation = new Violation(Severity.ERROR, path, detail, t); violation.setVerifierInfo(this); violationListener.reportViolation(violation); }
protected void error(String path, String detail) { Violation violation = new Violation(Severity.ERROR, path, detail); violation.setVerifierInfo(this); violationListener.reportViolation(violation); }
protected void warning(String path, String detail) { Violation violation = new Violation(Severity.WARNING, path, detail); violation.setVerifierInfo(this); violationListener.reportViolation(violation); }