/** * Extract the optional severity of a rule. * * @param attributes * The attributes of the rule. * @param defaultSeverity * The default severity to use if no severity is specified. * @return The severity. */ private Severity getSeverity(Attributes attributes, Severity defaultSeverity) throws RuleException { String severity = attributes.getString(SEVERITY); if (severity == null) { return defaultSeverity; } Severity value = Severity.fromValue(severity.toLowerCase()); return value != null ? value : defaultSeverity; }
/** * Writes the severity of the rule. * * @param severity * The severity the rule has been executed with * @throws XMLStreamException * If writing fails. */ private void writeSeverity(Severity severity) throws XMLStreamException { xmlStreamWriter.writeStartElement("severity"); xmlStreamWriter.writeAttribute("level", severity.getLevel().toString()); xmlStreamWriter.writeCharacters(severity.getValue()); xmlStreamWriter.writeEndElement(); }
/** * Return a string representing of the effective severity of a rule. * * @param effectiveSeverity * The severity to use. * @return The string representation. */ public String getInfo(Severity effectiveSeverity) { StringBuffer result = new StringBuffer(effectiveSeverity.name()); if (!this.equals(effectiveSeverity)) { result.append(" (from ").append(this.name()).append(")"); } return result.toString(); }
@Override public void withOptions(final CommandLine options) throws CliConfigurationException { super.withOptions(options); reportDirectory = getOptionValue(options, CMDLINE_OPTION_REPORTDIR, DEFAULT_REPORT_DIRECTORY); severity = Severity.valueOf(getOptionValue(options, CMDLINE_OPTION_SEVERITY, Severity.CRITICAL.name()).toUpperCase()); executeAppliedConcepts = options.hasOption(CMDLINE_OPTION_EXECUTEAPPLIEDCONCEPTS); }
if (Result.Status.FAILURE.equals(result.getStatus())) { ExecutableRule rule = result.getRule(); String severityInfo = rule.getSeverity().getInfo(result.getSeverity()); List<String> resultRows = getResultRows(result, logResult); boolean warn = warnOnSeverity != null && result.getSeverity().getLevel() <= warnOnSeverity.getLevel(); boolean fail = failOnSeverity != null && result.getSeverity().getLevel() <= failOnSeverity.getLevel(); LoggingStrategy loggingStrategy; if (fail) {
@Override public void visitConstraint(Constraint constraint, Severity effectiveSeverity) throws RuleException { analyzerContext.getLogger() .info("Validating constraint '" + constraint.getId() + "' with severity: '" + constraint.getSeverity().getInfo(effectiveSeverity) + "'."); try { analyzerContext.getStore().beginTransaction(); reportPlugin.beginConstraint(constraint); reportPlugin.setResult(execute(constraint, effectiveSeverity)); reportPlugin.endConstraint(); analyzerContext.getStore().commitTransaction(); } catch (XOException e) { analyzerContext.getStore().rollbackTransaction(); throw new RuleException("Cannot validate constraint " + constraint.getId(), e); } }
/** * Converts {@link Severity} to {@link SeverityEnumType} * * @param severity * {@link Severity}, can be <code>null</code> * @param defaultSeverity * default severity level, can be <code>null</code> * @return {@link SeverityEnumType} */ private SeverityEnumType getSeverity(Severity severity, Severity defaultSeverity) { if (severity == null) { severity = defaultSeverity; } return defaultSeverity != null ? SeverityEnumType.fromValue(severity.getValue()) : null; } }
if (severity.getLevel() <= failureSeverity.getLevel()) { Failure failure = new Failure(); failure.setMessage(rule.getDescription()); testcase.getFailure().add(failure); failures++; } else if (severity.getLevel() <= errorSeverity.getLevel()) { Error error = new Error(); error.setMessage(rule.getDescription());
@Override public boolean visitConcept(Concept concept, Severity effectiveSeverity) throws RuleException { try { analyzerContext.getStore().beginTransaction(); ConceptDescriptor conceptDescriptor = analyzerContext.getStore().find(ConceptDescriptor.class, concept.getId()); Result.Status status; if (conceptDescriptor == null || configuration.isExecuteAppliedConcepts()) { analyzerContext.getLogger() .info("Applying concept '" + concept.getId() + "' with severity: '" + concept.getSeverity().getInfo(effectiveSeverity) + "'."); reportPlugin.beginConcept(concept); Result<Concept> result = execute(concept, effectiveSeverity); reportPlugin.setResult(result); status = result.getStatus(); if (conceptDescriptor == null) { conceptDescriptor = analyzerContext.getStore().create(ConceptDescriptor.class); conceptDescriptor.setId(concept.getId()); conceptDescriptor.setStatus(status); } reportPlugin.endConcept(); } else { status = conceptDescriptor.getStatus(); } analyzerContext.getStore().commitTransaction(); return Result.Status.SUCCESS.equals(status); } catch (XOException e) { analyzerContext.getStore().rollbackTransaction(); throw new RuleException("Cannot apply concept " + concept.getId(), e); } }
private Severity getSeverity(String errorSeverity) throws ReportException { try { return Severity.fromValue(errorSeverity); } catch (RuleException e) { throw new ReportException("Cannot parse error severity " + errorSeverity, e); } }
private Map<String, Severity> getGroupElements(Attributes attributes, String attributeName) throws RuleException { Map<String, String> references = getReferences(attributes, attributeName); Map<String, Severity> result = new HashMap<>(); for (Map.Entry<String, String> entry : references.entrySet()) { String id = entry.getKey(); String dependencyAttribute = entry.getValue(); Severity severity = dependencyAttribute != null ? Severity.fromValue(dependencyAttribute.toLowerCase()) : null; result.put(id, severity); } return result; }
/** * Get the severity. * * @param severityType * The severity type. * @param defaultSeverity * The default severity. * @return The severity. */ private Severity getSeverity(SeverityEnumType severityType, Severity defaultSeverity) throws RuleException { return severityType == null ? defaultSeverity : Severity.fromValue(severityType.value()); } }
private Severity toSeverity(String value, RuleContext context) throws RuleException { if (value == null) { return getRuleConfiguration().getDefaultConceptSeverity(); } Severity severity = Severity.fromValue(value.toLowerCase()); return severity != null ? severity : getRuleConfiguration().getDefaultConceptSeverity(); }