/** * Creates a {@link ValueDescriptor}. * * @param valueDescriptorType * The type of the value descriptor. * @param <T> * The type of the value descriptor. * @return The value descriptor. */ <T extends ValueDescriptor<?>> T getValueDescriptor(Class<T> valueDescriptorType) { return scannerContext.getStore().create(valueDescriptorType); }
/** * Takes an optional descriptor and transforms it to file descriptor. * * @param descriptor * The descriptor, if <code>null</code> a new descriptor is * created. * @param type * The required type. * @param path * The path (to set as file name). * @param context * The scanner context. * @param <D> * The required type. * @return The file descriptor. */ protected <D extends FileDescriptor> D toFileDescriptor(Descriptor descriptor, Class<D> type, String path, ScannerContext context) { D result; if (descriptor == null) { result = context.getStore().create(type); result.setFileName(path); } else if (type.isAssignableFrom(descriptor.getClass())) { result = type.cast(descriptor); } else { result = context.getStore().addDescriptorType(descriptor, type); result.setFileName(path); } return result; } }
@Override public void afterGroup(Group group) throws RuleException { analyzerContext.getStore().beginTransaction(); reportPlugin.endGroup(); analyzerContext.getStore().commitTransaction(); }
/** * Finds or creates a repository descriptor for the given url. * * @param store * the {@link Store} * @param url * the repository url * @return a {@link MavenRepositoryDescriptor} for the given url. */ private MavenRepositoryDescriptor getRepositoryDescriptor(Store store, String url) { MavenRepositoryDescriptor repositoryDescriptor = store.find(MavenRepositoryDescriptor.class, url); if (repositoryDescriptor == null) { repositoryDescriptor = store.create(MavenRepositoryDescriptor.class); repositoryDescriptor.setUrl(url); } return repositoryDescriptor; }
if (!store.hasActiveTransaction()) { store.beginTransaction(); descriptor = scan(item, descriptor, path, scope, pipeline); store.commitTransaction(); } else { } catch (RuntimeException e) { if (store.hasActiveTransaction()) { store.rollbackTransaction();
/** * Adds a "Release" or "Snapshot" label to the given maven descriptor * depending on the artifact version type. * * @param descriptor * the descriptor * @param type * the expected descriptor type * @param resolvedArtifact * the resolved artifact * @param lastModified * last modified date (for snapshots only) * @param store * the store * @return the new created resolvedArtifact descriptor */ private <D extends MavenDescriptor> D markReleaseOrSnaphot(D descriptor, Class<? extends D> type, Artifact resolvedArtifact, long lastModified, Store store) { if (resolvedArtifact.isSnapshot()) { MavenSnapshotDescriptor snapshotDescriptor = store.addDescriptorType(descriptor, MavenSnapshotDescriptor.class); snapshotDescriptor.setLastModified(lastModified); return type.cast(snapshotDescriptor); } else { return store.addDescriptorType(descriptor, MavenReleaseDescriptor.class, type); } }
@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); } }
/** * Resolves a maven project. * * @param project * The project * @param expectedType * The expected descriptor type. * @param scannerContext * The scanner context. * @param <T> * The expected descriptor type. * @return The maven project descriptor. */ protected <T extends MavenProjectDescriptor> T resolveProject(MavenProject project, Class<T> expectedType, ScannerContext scannerContext) { Store store = scannerContext.getStore(); String id = project.getGroupId() + ":" + project.getArtifactId() + ":" + project.getVersion(); MavenProjectDescriptor projectDescriptor = store.find(MavenProjectDescriptor.class, id); if (projectDescriptor == null) { projectDescriptor = store.create(expectedType, id); projectDescriptor.setName(project.getName()); projectDescriptor.setGroupId(project.getGroupId()); projectDescriptor.setArtifactId(project.getArtifactId()); projectDescriptor.setVersion(project.getVersion()); projectDescriptor.setPackaging(project.getPackaging()); projectDescriptor.setFullQualifiedName(id); } else if (!expectedType.isAssignableFrom(projectDescriptor.getClass())) { projectDescriptor = store.migrate(projectDescriptor, expectedType); } return expectedType.cast(projectDescriptor); }
@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); } }
private MavenArtifactDescriptor find(Coordinates coordinates, ScannerContext scannerContext) { String id = MavenArtifactHelper.getId(coordinates); Map<String, Object> params = new HashMap<>(); params.put("fqn", id); Query.Result<CompositeRowObject> result = scannerContext.getStore().executeQuery("MATCH (a:Maven:Artifact:File) WHERE a.fqn={fqn} RETURN a", params); return result.hasResult() ? result.getSingleResult().get("a", MavenArtifactDescriptor.class) : null; }
@Override public PackageDescriptor scan(DirectoryResource item, String path, Scope scope, Scanner scanner) throws IOException { ScannerContext context = scanner.getContext(); DirectoryDescriptor directoryDescriptor = context.getCurrentDescriptor(); PackageDescriptor descriptor = context.getStore().addDescriptorType(directoryDescriptor, PackageDescriptor.class); String packageName = path.substring(1).replaceAll("/", "."); String name; int separatorIndex = packageName.lastIndexOf('.'); if (separatorIndex != -1) { name = packageName.substring(separatorIndex + 1); } else { name = packageName; } descriptor.setName(name); descriptor.setFullQualifiedName(packageName); return descriptor; }
Result<CompositeRowObject> queryResult = store.executeQuery(((CypherExecutable) executable).getStatement(), queryParameters);
@Override protected DirectoryDescriptor getContainerDescriptor(File container, ScannerContext scannerContext) { return scannerContext.getStore().create(DirectoryDescriptor.class); }
@Override public PropertyFileDescriptor scan(FileResource item, String path, Scope scope, Scanner scanner) throws IOException { ScannerContext context = scanner.getContext(); Store store = context.getStore(); FileDescriptor fileDescriptor = context.getCurrentDescriptor(); PropertyFileDescriptor propertyFileDescriptor = store.addDescriptorType(fileDescriptor, PropertyFileDescriptor.class); Properties properties = new Properties(); try (InputStream stream = item.createStream()) { properties.load(stream); } catch (IllegalArgumentException e) { LOGGER.warn("Cannot load properties from '" + path + "': " + e.getMessage()); } for (String name : properties.stringPropertyNames()) { String value = properties.getProperty(name); PropertyDescriptor propertyDescriptor = store.create(PropertyDescriptor.class); propertyDescriptor.setName(name); propertyDescriptor.setValue(value); propertyFileDescriptor.getProperties().add(propertyDescriptor); } return propertyFileDescriptor; }
@Override public GZipFileDescriptor scan(final FileResource item, String path, Scope scope, Scanner scanner) throws IOException { ScannerContext context = scanner.getContext(); Store store = context.getStore(); final FileDescriptor fileDescriptor = context.peek(FileDescriptor.class); GZipFileDescriptor gZipFileDescriptor = store.addDescriptorType(fileDescriptor, GZipFileDescriptor.class); String uncompressedPath = path.substring(0, path.toLowerCase().indexOf(".gz")); try (FileResource fileResource = new BufferedFileResource(new AbstractFileResource() { @Override public InputStream createStream() throws IOException { return new GZIPInputStream(item.createStream()); } })) { FileDescriptor entryDescriptor = scanner.scan(fileResource, uncompressedPath, scope); gZipFileDescriptor.getContains().add(entryDescriptor); } return gZipFileDescriptor; } }
@Override public void beforeGroup(Group group, Severity effectiveSeverity) throws RuleException { analyzerContext.getLogger().info("Executing group '" + group.getId() + "'"); analyzerContext.getStore().beginTransaction(); reportPlugin.beginGroup(group); analyzerContext.getStore().commitTransaction(); }
protected <T extends ExecutableRule<?>> Result<T> execute(String cypher, T executableRule, Map<String, Object> parameters, Severity severity, AnalyzerContext context) throws RuleException { List<Map<String, Object>> rows = new ArrayList<>(); context.getLogger().debug("Executing query '" + cypher + "' with parameters [" + parameters + "]"); List<String> columnNames = null; try (Query.Result<Query.Result.CompositeRowObject> compositeRowObjects = context.getStore().executeQuery(cypher, parameters)) { for (Query.Result.CompositeRowObject rowObject : compositeRowObjects) { if (columnNames == null) { columnNames = new ArrayList<>(rowObject.getColumns()); } Map<String, Object> row = new LinkedHashMap<>(); for (String columnName : columnNames) { row.put(columnName, rowObject.get(columnName, Object.class)); } rows.add(row); } } catch (Exception e) { throw new RuleException("Cannot execute query for rule '" + executableRule + "'.", e); } Status status = getStatus(executableRule, columnNames, rows, context); return Result.<T>builder().rule(executableRule).status(status).severity(severity).columnNames(columnNames).rows(rows).build(); }
@Override protected DirectoryDescriptor getContainerDescriptor(File container, ScannerContext scannerContext) { return scannerContext.getStore().create(DirectoryDescriptor.class); }
@Override public PropertyFileDescriptor scan(FileResource item, String path, Scope scope, Scanner scanner) throws IOException { ScannerContext context = scanner.getContext(); Store store = context.getStore(); FileDescriptor fileDescriptor = context.getCurrentDescriptor(); Class<XmlPropertyFileDescriptor> descriptorType = XmlPropertyFileDescriptor.class; PropertyFileDescriptor propertyFileDescriptor = store.addDescriptorType(fileDescriptor, descriptorType); Properties properties = new Properties(); try (InputStream stream = item.createStream()) { properties.loadFromXML(stream); } catch (IllegalArgumentException e) { LOGGER.warn("Cannot load properties from '" + path + "': " + e.getMessage()); } for (String name : properties.stringPropertyNames()) { String value = properties.getProperty(name); PropertyDescriptor propertyDescriptor = store.create(PropertyDescriptor.class); propertyDescriptor.setName(name); propertyDescriptor.setValue(value); propertyFileDescriptor.getProperties().add(propertyDescriptor); } return propertyFileDescriptor; }
@Override public ServiceLoaderDescriptor scan(FileResource item, String path, Scope scope, Scanner scanner) throws IOException { Matcher matcher = PATTERN.matcher(path); if (!matcher.matches()) { throw new IOException("Cannot match path name: " + path); } String serviceInterface = matcher.group(2); ScannerContext context = scanner.getContext(); FileDescriptor fileDescriptor = context.getCurrentDescriptor(); ServiceLoaderDescriptor serviceLoaderDescriptor = context.getStore().addDescriptorType(fileDescriptor, ServiceLoaderDescriptor.class); TypeDescriptor interfaceTypeDescriptor = getTypeDescriptor(serviceInterface, context); serviceLoaderDescriptor.setType(interfaceTypeDescriptor); try (InputStream stream = item.createStream()) { BufferedReader reader = new BufferedReader(new InputStreamReader(stream)); String serviceImplementation; while ((serviceImplementation = reader.readLine()) != null) { if (!isEmptyOrComment(serviceImplementation)) { TypeDescriptor implementationTypeDescriptor = getTypeDescriptor(serviceImplementation, context); serviceLoaderDescriptor.getContains().add(implementationTypeDescriptor); } } } return serviceLoaderDescriptor; }