io.sealights.agents.plugin.ProjectDataCollector Maven / Gradle / Ivy

package io.sealights.agents.plugin;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Properties;
import java.util.Set;

import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.ModuleVersionIdentifier;
import org.gradle.api.artifacts.ResolvedArtifact;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.plugins.JavaPluginConvention;
import org.gradle.api.tasks.SourceSet;

import io.sealights.onpremise.agents.java.agent.infra.utils.StringUtils;
import io.sealights.onpremise.agents.java.agent.plugins.engine.api.DependencyInfo;
import io.sealights.onpremise.agents.java.agent.plugins.engine.api.ProjectDescriptor;

public class ProjectDataCollector {

    private final static String SEALIGHTS_GRADLE_PLUGIN = "sealights-gradle-plugin";
    private Project rootProject;

    public static ProjectDescriptor execute(Project rootProject) {
    		ProjectDataCollector instance = new ProjectDataCollector(rootProject);
    		return instance.collectProjectData();
    }

    private ProjectDataCollector(Project rootProject) {
        this.rootProject = rootProject;
    }

    private ProjectDescriptor collectProjectData() {
    	try {
	        return new ProjectDescriptor(
	                SEALIGHTS_GRADLE_PLUGIN,
	                resolvePluginVersion(),
	                rootProject.getName(),
	                rootProject.getVersion().toString(),
	                collectProperties(),
	                resolveBaseSourceDir(),
	                rootProject.getProjectDir().getAbsolutePath(),
	                rootProject.getBuildDir().getAbsolutePath(),
	                collectDependenciesData(),
	                collectPluginsData());
    	}
    	catch(Exception e) {
    		// Catch any null pointer exception instead of checking each getMethod 
    		return new ProjectDescriptor();
    	}
    }
    
    private String resolvePluginVersion() {
    	return "[-]";
    }

    private Properties collectProperties() {
        Properties destProps = new Properties();
        // This is too much ...
//        Map projectProps = project.getProperties();
//        for (String key : projectProps.keySet()) {
//            Object value = projectProps.get(key);
//            if (value != null) {
//                destProps.setProperty(key, value.toString());
//            }
//        }
        return destProps;
    }

    private List collectDependenciesData(){
        Set dependencies = new HashSet<>();
        dependencies = collectProjectDependencies(rootProject);
        for (Project subproject : rootProject.getAllprojects()){
            dependencies.addAll(collectProjectDependencies(subproject));
        }
        List dependenciesAsList = new ArrayList<>();
        dependenciesAsList.addAll(dependencies);
        return dependenciesAsList;
    }

    private Set collectProjectDependencies(Project project) {
        Set dependenciesData = new HashSet<>();
        Configuration runtimeCfg = project.getConfigurations().getByName("runtime");
        if ( runtimeCfg != null && runtimeCfg.getResolvedConfiguration() != null) {
            Set artifacts = runtimeCfg.getResolvedConfiguration().getResolvedArtifacts();
            for (ResolvedArtifact a : artifacts) {
            	DependencyInfo dependencyInfo = artifactAsDependecyInfo(a);
            	if (dependencyInfo != null) {
                    dependenciesData.add(dependencyInfo);
                }
            }
        }
        return dependenciesData;
    }
    
    private DependencyInfo artifactAsDependecyInfo(ResolvedArtifact artifact) {
        if (artifact.getModuleVersion() != null && artifact.getModuleVersion().getId() != null ) {
            // Artifact may have either module version or module version id 'null'
            // Put dependencies of "good" artifacts only
            ModuleVersionIdentifier moduleVersion =  artifact.getModuleVersion().getId();

            return new DependencyInfo(
                            notNullValue(moduleVersion.getGroup()),
                            notNullValue(moduleVersion.getName()),
                            notNullValue(moduleVersion.getVersion()));
        }
        else {
        	return null;
        }
    }

    private String notNullValue(String value) {
        return value != null ? value : StringUtils.EMPTY_STRING;
    }

    private List collectPluginsData() {
        List pluginsData = new ArrayList<>();
        for (Plugin p: rootProject.getPlugins()) {
            pluginsData.add(new DependencyInfo("[-]", p.getClass().getSimpleName(), "[-]"));
        }
        return pluginsData;
    }

    private String resolveBaseSourceDir() {
    	String defaultSrcDir = rootProject.getPath();
    	try {
    		boolean javaPlugin = rootProject.getPlugins().hasPlugin(JavaPlugin.class); 
    		if (javaPlugin ) {
    			   JavaPluginConvention javaPluginConvention = rootProject.getConvention().getPlugin(JavaPluginConvention.class); 
    			   SourceSet main = javaPluginConvention.getSourceSets().getByName(SourceSet.MAIN_SOURCE_SET_NAME); 
    			   return main.getOutput().getAsPath();
    		} 
    	}
    	catch(Exception e) {
    		// Catch any null pointer exception instead of checking each getMethod
    	}
    	return defaultSrcDir;
    }	

}