Java Module类代码示例

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
@Override
public GrapesNotification createAutoInstance(AbstractBuild<?, ?> build) {
    GrapesMavenPluginNotification notification = null;
    try{
        final GrapesNotifier notifier = GrapesPlugin.getGrapesNotifier(build.getProject());
        if(notifier == null || !notifier.getManageGrapesMavenPlugin()){
            return null;
        }

        final FilePath moduleFilePath = GrapesPlugin.getBuildModuleFile(build);
        if(!moduleFilePath.exists()){
            return null;
        }

        final Module module = GrapesPlugin.getModule(moduleFilePath);

        notification = new GrapesMavenPluginNotification();
        notification.setModuleName(module.getName());
        notification.setModuleVersion(module.getVersion());
        notification.setModuleFilePath(moduleFilePath);
    } catch (Exception e) {
        GrapesPlugin.getLogger().log(Level.SEVERE, "[GRAPES] Failed to get build Maven Grapes report ", e);
    }

    return notification;
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
@Override
public GrapesNotification createAutoInstance(final AbstractBuild<?, ?> build) {
    try{
        final GrapesNotifier notifier = GrapesPlugin.getGrapesNotifier(build.getProject());
        if(notifier == null || !notifier.getManageBuildInfo()){
            return null;
        }

        final FilePath moduleFile = GrapesPlugin.getBuildModuleFile(build);
        final Module module = GrapesPlugin.getModule(moduleFile);

        final BuildInfoNotification notification = new BuildInfoNotification();
        notification.setModuleName(module.getName());
        notification.setModuleVersion(module.getVersion());
        notification.setMimePath(GrapesPlugin.getBuildBuildInfoFile(build));

        return notification;

    } catch (Exception e) {
        GrapesPlugin.getLogger().log(Level.SEVERE, "[GRAPES] Failed to get build Module buildInfo ", e);
    }

    return null;
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
/**
 * Checks all the available reports and aggregates the existing ones
 *
 * @throws IOException
 * @throws MojoExecutionException
 */
public void aggregate() throws IOException, MojoExecutionException {
    final Map<String, File> subModules = getSubModuleReports();

    for(Map.Entry<String,File> submoduleReports : subModules.entrySet()){
        final MavenProject parentProject = getParentProject(submoduleReports.getKey());

        if(parentProject != null){
            final Module subModule = JsonUtils.unserializeModule(FileUtils.read(submoduleReports.getValue()));
            final Boolean updated = updateParent(parentProject, subModule);

            // removes the children that are taken into accounts into parent reports
            if(updated){
                final File subModuleFile = new File(workingFolder, GrapesMavenPlugin.getSubModuleFileName(submoduleReports.getKey()));
                subModuleFile.delete();
            }
        }
    }
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
private Module getSubModule(final Module rootModule, final MavenProject parentProject) {
    final String parentSubModuleName = GrapesTranslator.generateModuleName(parentProject);

    for(Module subModule: rootModule.getSubmodules()){
        if(subModule.getName().equals(parentSubModuleName)){
            return subModule;
        }

        final Module result = getSubModule(subModule,parentProject);
        if(result != null){
            return result;
        }
    }

    return null;
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
@Test
public void generateModule(){
    final String mainArtifactGid = "org.axway.grapes.test";
    final String mainArtifactId = "mainArtifactId";
    final String moduleVersion = "1.1.2-3";

    final org.apache.maven.artifact.Artifact artifact = mock(org.apache.maven.artifact.Artifact.class);
    when(artifact.getGroupId()).thenReturn(mainArtifactGid);
    when(artifact.getArtifactId()).thenReturn(mainArtifactId);

    final MavenProject project = mock(MavenProject.class);
    when(project.getArtifact()).thenReturn(artifact);
    when(project.getVersion()).thenReturn(moduleVersion);

    final Module module = GrapesTranslator.getGrapesModule(project);
    assertEquals(mainArtifactGid + ":" + mainArtifactId, module.getName());
    assertEquals(moduleVersion, module.getVersion());
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
/**
 * Un-serialize a Module from Json file
 *
 * @param moduleFile File
 * @return Module
 * @throws IOException
 * @throws InterruptedException
 */
public static Module getModule(final FilePath moduleFile) throws IOException, InterruptedException {
    if (moduleFile.exists()) {
        final String serializedModule= moduleFile.readToString();
        return JsonUtils.unserializeModule(serializedModule);
    }

    getLogger().severe("[GRAPES] Wrong module report path: " + moduleFile.toURI().getPath());
    throw new IOException("[GRAPES] Failed to get report.");
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
/**
 * Initiate the report
 *
 * @param module Module
 * @param grapesClient GrapesClient
 */
public GrapesBuildAction(final Module module, final GrapesClient grapesClient) {
   if(grapesClient == null ||
            module == null ){
        return;
    }

    title = "Dependency  report of " + module.getName() + " in version " + module.getVersion();

    // Init the report with Grapes server information
    try{
        final Organization organization = grapesClient.getModuleOrganization(module.getName(), module.getVersion());
        final List<String> corporateFilters = organization.getCorporateGroupIdPrefixes();
        dependencies = new HashMap<Dependency, String>();

        final List<Dependency> moduleDependencies = ModuleUtils.getCorporateDependencies(module, corporateFilters);
        for(Dependency dependency: moduleDependencies){
            final String lastVersion = getLastVersion(grapesClient, dependency);
            this.dependencies.put(dependency, lastVersion);
        }

        thirdParty = ModuleUtils.getThirdPartyLibraries(module, corporateFilters);
        ancestors = grapesClient.getModuleAncestors(module.getName(), module.getVersion());

        initOk = true;

    } catch (Exception e){
        GrapesPlugin.getLogger().log(Level.WARNING, "Failed to generate build dependency report for " + module.getName(), e);
    }

}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
/**
 * Return a module from Json file in a targeted folder
 *
 * @param folder File
 * @param moduleJsonFileName String
 * @return Module
 * @throws MojoExecutionException
 * @throws IOException
 */
public static Module getModule(final File folder, final String moduleJsonFileName) throws MojoExecutionException, IOException {
    final File moduleFile = new File(folder, moduleJsonFileName);

    if(moduleFile.exists()){
        final String serializedModule = FileUtils.read(moduleFile);
        return JsonUtils.unserializeModule(serializedModule);
    }

    return null;
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
public void execute() throws MojoExecutionException {
	if (isExecuteSkipped()) {
		return;
	}
    // Execute only one time
    if(project.equals(reactorProjects.get(0))){
        try {
            final File workingFolder = GrapesMavenPlugin.getGrapesPluginWorkingFolder(reactorProjects.get(0));
            final Module rootModule = GrapesMavenPlugin.getModule(workingFolder, GrapesMavenPlugin.MODULE_JSON_FILE_NAME);
            getLog().info("Sending " + rootModule.getName() + "...");

            getLog().info("Connection to Grapes");
            getLog().info("Host: " + host);
            getLog().info("Port: " + port);
            getLog().info("User: " + user);
            final GrapesClient client = new GrapesClient(host, port);

            if(!client.isServerAvailable()){
                throw new MojoExecutionException("Grapes is unreachable");
            }

            client.postModule(rootModule, user, password);

            getLog().info("Information successfully sent");

        } catch (Exception e) {
            if(failOnError){
                throw new MojoExecutionException("An error occurred during Grapes server Notification." , e);
            }
            else{
                getLog().debug("An error occurred during Grapes server Notification.", e);
                getLog().info("Failed to send information to Grapes");
            }
        }
    }
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
/**
 * @throws Exception
 */
public void testSimpleProjectWithOneModuleOneArtifactAndOneLicense() throws Exception {
    File pom = getTestFile( "src/test/resources/materials/simple-project/pom.xml" );
    assertNotNull( pom );
    assertTrue( pom.exists() );

    final GenerateMojo generateMojo = (GenerateMojo) lookupMojo( "generate", pom );
    final MavenProject simpleProject = (MavenProject) getVariableValueFromObject( generateMojo, "project" );

    /* Fake artifact resolution */
    final RepositorySystem repositorySystemMock = mock(RepositorySystem.class);
    final ArtifactResolutionResult result = mock(ArtifactResolutionResult.class);
    when(repositorySystemMock.resolve(any(ArtifactResolutionRequest.class))).thenReturn(result);
    when(result.isSuccess()).thenReturn(true);

    setVariableValueToObject(generateMojo, "repositorySystem", repositorySystemMock);
    /* End */

    // Runs Mojo on the project
    generateMojo.execute();

    // Get generated Grapes module
    final String serializedModule = FileUtils.read(new File(simpleProject.getBasedir(), "target/grapes/"+GrapesMavenPlugin.MODULE_JSON_FILE_NAME));
    final Module simpleProjectModule = JsonUtils.unserializeModule(serializedModule);

    // Checks
    assertEquals(simpleProject.getGroupId() + ":" + simpleProject.getArtifactId() , simpleProjectModule.getName());
    assertEquals(simpleProject.getVersion() , simpleProjectModule.getVersion());
    assertEquals(0 , simpleProjectModule.getSubmodules().size());
    assertEquals(2 , simpleProjectModule.getArtifacts().size());

    final Artifact grapesArtifact = simpleProjectModule.getArtifacts().iterator().next();
    assertEquals(simpleProject.getArtifact().getGroupId() , grapesArtifact.getGroupId());
    assertEquals(simpleProject.getArtifact().getArtifactId() , grapesArtifact.getArtifactId());
    assertEquals(simpleProject.getArtifact().getVersion() , grapesArtifact.getVersion());
    assertEquals(simpleProject.getLicenses().get(0).getName(), grapesArtifact.getLicenses().get(0));

}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
/**
 * Sends a notification to Grapes server
 *
 * @param notification GrapesNotification
 * @throws GrapesCommunicationException
 */
public void send(final GrapesNotification notification, final AbstractBuild<?,?> build) throws GrapesCommunicationException {
    try{
        // perform the notification
        switch (notification.getNotificationAction()){
            case POST_MODULE:
                // Send the module
                final FilePath moduleFilePath = notification.getMimePath();
                final Module module = GrapesPlugin.getModule(moduleFilePath);
                client.postModule(module, user, password);

                // Generate build action with the dependency report
                final GrapesBuildAction buildAction = new GrapesBuildAction(module, client);

                // Add dependency report to the build
                if (buildAction.isInitOk()) {
                    build.addAction(buildAction);
                }
                break;
            case PROMOTE:
                client.promoteModule(notification.getModuleName(), notification.getModuleVersion(), user, password);
                break;
            case POST_MODULE_BUILD_INFO:
                final FilePath buildInfoPath = notification.getMimePath();
                final Map<String, String> buildInfo = GrapesPlugin.getBuildInfo(buildInfoPath);
                client.postBuildInfo(notification.getModuleName(), notification.getModuleVersion(), buildInfo, user, password);
                break;
            default:break;
        }

        //discard old resend action if matches moduleName moduleVersion notification type
        discardOldResend(notification, build.getProject());
    }

    catch (Exception e) {
        GrapesPlugin.getLogger().log(Level.SEVERE, "[GRAPES] An error occurred during notification sending ", e);
        discardOldResend(notification, build.getProject());
        saveNotification(notification, build);
        throw new GrapesCommunicationException(e.getMessage(), 500);

    }
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
public Module getModule() {
    return module;
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
public void execute() throws MojoExecutionException {
	if (isExecuteSkipped()) {
		return;
	}
    try {
        final ModuleAggregator aggregator = new ModuleAggregator(reactorProjects);
        final ModuleBuilder moduleBuilder = new ModuleBuilder();
        final ArtifactResolver artifactResolver = new ArtifactResolver(repositorySystem, localRepository, getLog());
        final LicenseResolver licenseResolver = new LicenseResolver(repositorySystem, localRepository, getLog());

        getLog().info("Collecting dependency information of " + project.getName());
        final Module module = moduleBuilder.getModule(project, licenseResolver, artifactResolver);

        // Serialize the collected information
        final String serializedModule = JsonUtils.serialize(module);
        getLog().debug("Json module : " + serializedModule);

        // Write file
        final File grapesFolder = GrapesMavenPlugin.getGrapesPluginWorkingFolder(reactorProjects.get(0));
        getLog().info("Serializing the notification in " + grapesFolder.getPath());

        if(project.equals(reactorProjects.get(0))){
            FileUtils.serialize(grapesFolder, serializedModule, GrapesMavenPlugin.MODULE_JSON_FILE_NAME);
        }
        else{
            final String subModuleName = project.getBasedir().getName();
            FileUtils.serialize(grapesFolder, serializedModule, GrapesMavenPlugin.getSubModuleFileName(subModuleName));
        }

        getLog().info("Report consolidation...");
        aggregator.aggregate();

    } catch (Exception e) {

        if(failOnError){
            throw new MojoExecutionException("An error occurred during Grapes reporting." , e);
        }
        else{
            getLog().debug("An error occurred during Grapes reporting.", e);
            getLog().error("Failed to build Grapes report.");
        }
    }
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
/**
 * Turn a maven project (Maven data model) into a module (Grapes data model)
 *
 * @param project MavenProject
 * @return Module
 */
public Module getModule(final MavenProject project, final LicenseResolver licenseResolver, final ArtifactResolver artifactResolver) throws MojoExecutionException {

    final Module module = GrapesTranslator.getGrapesModule(project);
    final List<License> licenses = licenseResolver.resolve(project);

    /* Manage Artifacts */
    final Artifact mainArtifact = GrapesTranslator.getGrapesArtifact(project.getArtifact());
    addLicenses(mainArtifact, licenses);
    module.addArtifact(mainArtifact);

    // Get pom file if main artifact is not already a pom file
    if(!mainArtifact.getType().equals("pom")){
        final Artifact pomArtifact = GrapesTranslator.getGrapesArtifact(project.getModel());
        addLicenses(pomArtifact, licenses);
        module.addArtifact(pomArtifact);
    }

    for(int i = 0 ; i < project.getAttachedArtifacts().size() ; i++){
        artifactResolver.resolveArtifact(project, project.getAttachedArtifacts().get(i));
        final Artifact attachedArtifact = GrapesTranslator.getGrapesArtifact(project.getAttachedArtifacts().get(i));
        // handle licenses
        addLicenses(attachedArtifact, licenses);
        module.addArtifact(attachedArtifact);
    }

    /* Manage Dependencies */
    for(int i = 0 ; i < project.getDependencies().size() ; i++){
        final Dependency dependency = GrapesTranslator.getGrapesDependency(
                artifactResolver.resolveArtifact(project, project.getDependencies().get(i)),
                    project.getDependencies().get(i).getScope());

        // handle licenses
        for(License license: licenseResolver.resolve(
                project,
                dependency.getTarget().getGroupId(),
                dependency.getTarget().getArtifactId(),
                dependency.getTarget().getVersion())){
            dependency.getTarget().addLicense(license.getName());
        }

        module.addDependency(dependency);
    }

    return module;
}
 

import org.axway.grapes.commons.datamodel.Module; //导入依赖的package包/类
/**
 * Checks if a module has a project as sub module
 *
 * @param rootModule Module
 * @param parentProject MavenProject
 * @return boolean
 */
private boolean contains(final Module rootModule, final MavenProject parentProject) {
    return getSubModule(rootModule, parentProject) != null;
}