Ejemplo n.º 1
0
 public static DependencyId newInstance(Artifact artifact) {
   return new DependencyId(
       artifact.getGroupId(),
       artifact.getArtifactId(),
       artifact.getClassifier(),
       artifact.getExtension());
 }
Ejemplo n.º 2
0
  @Override
  public DependencyMetadata resolveDependencyMetadata(
      Dependency query, final List<DependencyRepository> repositories) {
    try {
      if (Strings.isNullOrEmpty(query.getVersion())) {
        query = DependencyBuilder.create(query).setVersion("[,)");
      }

      RepositorySystem system = container.lookup(RepositorySystem.class);
      MavenRepositorySystemSession session = setupRepoSession(system);

      DefaultArtifact artifact = new DefaultArtifact(query.toCoordinates());

      ArtifactDescriptorRequest ar =
          new ArtifactDescriptorRequest(artifact, convertToMavenRepos(repositories), null);
      ArtifactDescriptorResult results = system.readArtifactDescriptor(session, ar);

      Artifact a = results.getArtifact();
      Dependency d =
          DependencyBuilder.create()
              .setArtifactId(a.getArtifactId())
              .setGroupId(a.getGroupId())
              .setVersion(a.getVersion());

      return new DependencyMetadataImpl(d, results);
    } catch (Exception e) {
      throw new ProjectModelException(
          "Unable to resolve any artifacts for query [" + query + "]", e);
    }
  }
  @Test
  public void testLookup() throws ArtifactDescriptorException {
    StubArtifact art = new StubArtifact("gid:aid:ext:ver");
    ArtifactDescriptorRequest request = new ArtifactDescriptorRequest(art, null, "");
    ArtifactDescriptorResult description = reader.readArtifactDescriptor(session, request);

    assertEquals(request, description.getRequest());
    assertEquals(art, description.getArtifact());

    assertEquals(1, description.getRelocations().size());
    Artifact artifact = description.getRelocations().get(0);
    assertEquals("gid", artifact.getGroupId());
    assertEquals("aid", artifact.getArtifactId());
    assertEquals("ver", artifact.getVersion());
    assertEquals("ext", artifact.getExtension());

    assertEquals(1, description.getRepositories().size());
    RemoteRepository repo = description.getRepositories().get(0);
    assertEquals("id", repo.getId());
    assertEquals("type", repo.getContentType());
    assertEquals("protocol://some/url?for=testing", repo.getUrl());

    assertDependencies(description.getDependencies());
    assertDependencies(description.getManagedDependencies());
  }
Ejemplo n.º 4
0
  public void upload(
      String groupId, String artifactId, String version, String extension, Generator writer)
      throws Exception {
    File file =
        File.createTempFile(
            String.format("%s-%s-%s", groupId, artifactId, version), "." + extension);
    try {
      FileOutputStream out = new FileOutputStream(file);
      try {
        writer.write(out);
      } finally {
        out.close();
      }

      Artifact artifact =
          new DefaultArtifact(groupId, artifactId, extension, version).setFile(file);

      // Install the artifact locally
      repositorySystem.install(session, new InstallRequest().addArtifact(artifact));

      // Deploy the artifact remotely
      DeployRequest deployRequest = new DeployRequest().addArtifact(artifact);

      if (artifact.isSnapshot()) {
        Preconditions.checkNotNull(snapshotsRepository, "snapshots repository uri is null");
        deployRequest.setRepository(snapshotsRepository);
      } else {
        Preconditions.checkNotNull(releasesRepository, "releases repository uri is null");
        deployRequest.setRepository(releasesRepository);
      }
      repositorySystem.deploy(session, deployRequest);
    } finally {
      file.delete();
    }
  }
Ejemplo n.º 5
0
 public synchronized String getArtifactVersion(ReleaseId releaseId) {
   if (!releaseId.isSnapshot()) {
     return releaseId.getVersion();
   }
   Artifact artifact = getArtifactResolver().resolveArtifact(releaseId);
   return artifact != null ? artifact.getVersion() : null;
 }
 /**
  * Converts an Aether artifact to a Maven model dependency.
  *
  * @param artifact the Aether artifact to be converted
  * @return a Maven dependency with the same coordinates
  */
 private Dependency artifactToDependency(Artifact artifact) {
   final Dependency dependency = new Dependency();
   dependency.setGroupId(artifact.getGroupId());
   dependency.setArtifactId(artifact.getArtifactId());
   dependency.setVersion(artifact.getVersion());
   dependency.setType(artifact.getExtension());
   return dependency;
 }
 private static String getId(Artifact artifact) {
   return getId(
       artifact.getGroupId(),
       artifact.getArtifactId(),
       artifact.getExtension(),
       artifact.getClassifier(),
       artifact.getBaseVersion());
 }
Ejemplo n.º 8
0
 /**
  * Fetch all files found (JAR, ZIP, directories, etc).
  *
  * @return Set of files
  * @throws DependencyResolutionException If can't resolve
  */
 @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
 private Set<File> fetch() throws DependencyResolutionException {
   final Set<File> files = new LinkedHashSet<File>(0);
   for (String path : this.elements()) {
     files.add(new File(path));
   }
   for (Artifact artifact : this.artifacts()) {
     files.add(artifact.getFile());
   }
   return files;
 }
  @Test
  public void testImmutability() {
    String coords = "gid:aid:ext:cls:ver";
    HashMap<String, String> map = new HashMap<String, String>();
    map.put("someProperty", "someValue");

    Artifact a = new DefaultArtifact(coords);
    assertNotSame(a, a.setFile(new File("file")));
    assertNotSame(a, a.setVersion("otherVersion"));
    assertNotSame(a, a.setProperties(map));
  }
Ejemplo n.º 10
0
 /**
  * Resolves an artifact given its Maven coordinates.
  *
  * @param coordinates Maven artifact coordinates
  * @return resolved artifact file
  */
 public File resolveArtifact(final String coordinates) throws RuntimeException {
   try {
     Artifact artifact = artifactResolver.resolveArtifact(request().artifact(coordinates));
     if (artifact == null || artifact.getFile() == null || !artifact.getFile().exists()) {
       throw new RuntimeException(String.format("Artifact %s could not be resolved", coordinates));
     }
     return artifact.getFile();
   } catch (ArtifactResolutionException e) {
     throw new RuntimeException(e.getMessage(), e);
   }
 }
Ejemplo n.º 11
0
 private void updateKieModule(DependencyDescriptor oldDependency, Artifact artifact) {
   ReleaseId newReleaseId = new DependencyDescriptor(artifact).getReleaseId();
   ZipKieModule kieModule = createZipKieModule(newReleaseId, artifact.getFile());
   if (kieModule != null) {
     ResultsImpl messages = build(kieModule);
     if (messages.filterMessages(Message.Level.ERROR).isEmpty()) {
       ((InternalKieContainer) kieContainer)
           .updateDependencyToVersion(oldDependency.getArtifactReleaseId(), newReleaseId);
       oldDependency.setArtifactVersion(artifact.getVersion());
     }
   }
 }
Ejemplo n.º 12
0
 private void indexAtifacts() {
   Collection<DependencyDescriptor> deps = getArtifactResolver().getAllDependecies();
   for (DependencyDescriptor dep : deps) {
     if (!dep.isFixedVersion()) {
       Artifact artifact = getArtifactResolver().resolveArtifact(dep.getReleaseId());
       log.debug(artifact + " resolved to  " + artifact.getFile());
       if (isKJar(artifact.getFile())) {
         usedDependencies.put(dep.getReleaseId(), new DependencyDescriptor(artifact));
       }
     }
   }
 }
Ejemplo n.º 13
0
 private InternalKieModule buildArtifact(Artifact artifact, ArtifactResolver resolver) {
   DependencyDescriptor dependencyDescriptor = new DependencyDescriptor(artifact);
   ReleaseId releaseId = dependencyDescriptor.getReleaseId();
   if (releaseId.isSnapshot()) {
     ((ReleaseIdImpl) releaseId).setSnapshotVersion(artifact.getVersion());
   }
   ZipKieModule kieModule = createZipKieModule(releaseId, artifact.getFile());
   if (kieModule != null) {
     addDependencies(
         kieModule, resolver, resolver.getArtifactDependecies(dependencyDescriptor.toString()));
     build(kieModule);
   }
   return kieModule;
 }
Ejemplo n.º 14
0
 private void addDependencies(
     InternalKieModule kieModule,
     ArtifactResolver resolver,
     List<DependencyDescriptor> dependencies) {
   for (DependencyDescriptor dep : dependencies) {
     Artifact depArtifact = resolver.resolveArtifact(dep.getReleaseId());
     if (depArtifact != null && isKJar(depArtifact.getFile())) {
       ReleaseId depReleaseId = new DependencyDescriptor(depArtifact).getReleaseId();
       ZipKieModule zipKieModule = createZipKieModule(depReleaseId, depArtifact.getFile());
       if (zipKieModule != null) {
         kieModule.addKieDependency(zipKieModule);
       }
     }
   }
 }
  /**
   * Resolve maven URI into maven project.
   *
   * <p>Provides only model and artifact.
   */
  public static MavenProject newProject(String mavenURI) throws Exception {

    final Artifact artifact = newArtifact(mavenURI);

    final File input = artifact.getFile();

    final ModelReader reader = new DefaultModelReader();

    final Model model = reader.read(input, null);

    final MavenProject project = new MavenProject(model);

    project.setArtifact(RepositoryUtils.toArtifact(artifact));

    return project;
  }
Ejemplo n.º 16
0
  private Set<Artifact> processTransientDependencies(Dependency dependency, boolean sharedLibraries)
      throws MojoExecutionException {
    try {
      final Set<Artifact> artifacts = new LinkedHashSet<Artifact>();

      final CollectRequest collectRequest = new CollectRequest();

      collectRequest.setRoot(dependency);
      collectRequest.setRepositories(projectRepos);
      final DependencyNode node =
          repoSystem.collectDependencies(repoSession, collectRequest).getRoot();

      final DependencyRequest dependencyRequest =
          new DependencyRequest(
              node,
              new AndDependencyFilter(
                  new ScopeDependencyFilter(
                      Arrays.asList("compile", "runtime"), Arrays.asList("test")),
                  // Also exclude any optional dependencies
                  new DependencyFilter() {
                    @Override
                    public boolean accept(
                        DependencyNode dependencyNode, List<DependencyNode> dependencyNodes) {
                      return !dependencyNode.getDependency().isOptional();
                    }
                  }));

      repoSystem.resolveDependencies(repoSession, dependencyRequest);

      PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
      node.accept(nlg);

      final List<Dependency> dependencies = nlg.getDependencies(false);

      for (Dependency dep : dependencies) {
        final org.sonatype.aether.artifact.Artifact depAetherArtifact = dep.getArtifact();
        if (isNativeLibrary(sharedLibraries, depAetherArtifact.getExtension())) {
          final Artifact mavenArtifact =
              artifactFactory.createDependencyArtifact(
                  depAetherArtifact.getGroupId(),
                  depAetherArtifact.getArtifactId(),
                  VersionRange.createFromVersion(depAetherArtifact.getVersion()),
                  depAetherArtifact.getExtension(),
                  depAetherArtifact.getClassifier(),
                  dep.getScope());
          mavenArtifact.setFile(depAetherArtifact.getFile());
          artifacts.add(mavenArtifact);
        }
      }

      return artifacts;
    } catch (Exception e) {
      throw new MojoExecutionException("Error while processing transient dependencies", e);
    }
  }
 public boolean isMarkerOlder(Artifact artifact1) throws MojoExecutionException {
   File marker = getMarkerFile();
   if (marker.exists()) {
     return artifact1.getFile().lastModified() > marker.lastModified();
   } else {
     // if the marker doesn't exist, we want to copy so assume it is
     // infinately older
     return true;
   }
 }
Ejemplo n.º 18
0
 /**
  * Artifact exists in collection?
  *
  * @param artifact The artifact
  * @param artifacts Collection of them
  * @return TRUE if it is already there
  */
 private static boolean contains(final Artifact artifact, final Collection<Artifact> artifacts) {
   boolean contains = false;
   for (Artifact exists : artifacts) {
     if (artifact.getArtifactId().equals(exists.getArtifactId())
         && artifact.getGroupId().equals(exists.getGroupId())
         && artifact.getClassifier().equals(exists.getClassifier())) {
       contains = true;
       break;
     }
   }
   return contains;
 }
Ejemplo n.º 19
0
  public File findArtifact(Artifact artifact) {
    MavenJPackageDepmap.debug(
        "=============JAVADIRREADER-FIND_ARTIFACT: " + artifact.getArtifactId());
    StringBuffer path = new StringBuffer();

    String artifactId = artifact.getArtifactId();
    String groupId = artifact.getGroupId();
    String version = artifact.getVersion();

    MavenJPackageDepmap.debug("Wanted GROUPID=" + groupId);
    MavenJPackageDepmap.debug("Wanted ARTIFACTID=" + artifactId);

    if (!groupId.startsWith("JPP")) {
      MavenJPackageDepmap map = MavenJPackageDepmap.getInstance();
      Hashtable<String, String> newInfo = map.getMappedInfo(groupId, artifactId, version);

      groupId = (String) newInfo.get("group");
      artifactId = (String) newInfo.get("artifact");
    }
    MavenJPackageDepmap.debug("Resolved GROUPID=" + groupId);
    MavenJPackageDepmap.debug("Resolved ARTIFACTID=" + artifactId);

    if (artifact.getExtension().equals("pom")) {
      path = getPOMPath(groupId, artifactId);
    } else if (artifact.getExtension().equals("signature")) {
      path.append("/usr/share/maven/repository/");
      path.append(groupId).append('/');
      path.append(artifactId).append(".signature");
    } else if (artifact.getExtension().equals("zip")) {
      path.append("/usr/share/maven/repository/");
      path.append(groupId).append('/');
      path.append(artifactId).append(".zip");
    } else {
      path.append("/usr/share/maven/repository/");
      path.append(groupId).append('/');
      path.append(artifactId).append(".jar");
    }

    MavenJPackageDepmap.debug("Returning " + path.toString());
    File ret = new File(path.toString());
    // if file doesn't exist return null to delegate to other
    // resolvers (reactor/local repo)
    if (ret.isFile()) {
      MavenJPackageDepmap.debug("Returning " + path.toString());
      return ret;
    } else {
      MavenJPackageDepmap.debug("Returning null for gid:aid =>" + groupId + ":" + artifactId);
      return null;
    }
  }
 public String getClassidier() {
   return artifact.getClassifier();
 }
  private void assertDependencies(List<Dependency> deps) {
    assertEquals(4, deps.size());

    Dependency dep = deps.get(0);
    assertEquals("scope", dep.getScope());
    assertEquals(false, dep.isOptional());
    assertEquals(2, dep.getExclusions().size());
    Iterator<Exclusion> it = dep.getExclusions().iterator();
    Exclusion excl = it.next();
    assertEquals("gid3", excl.getGroupId());
    assertEquals("aid", excl.getArtifactId());
    excl = it.next();
    assertEquals("gid2", excl.getGroupId());
    assertEquals("aid2", excl.getArtifactId());

    Artifact art = dep.getArtifact();
    assertEquals("gid", art.getGroupId());
    assertEquals("aid", art.getArtifactId());
    assertEquals("ver", art.getVersion());
    assertEquals("ext", art.getExtension());

    dep = deps.get(1);
    assertEquals("scope", dep.getScope());
    assertEquals(true, dep.isOptional());
    assertEquals(0, dep.getExclusions().size());

    art = dep.getArtifact();
    assertEquals("gid", art.getGroupId());
    assertEquals("aid2", art.getArtifactId());
    assertEquals("ver", art.getVersion());
    assertEquals("ext", art.getExtension());

    dep = deps.get(2);
    assertEquals("scope", dep.getScope());
    assertEquals(true, dep.isOptional());
    assertEquals(0, dep.getExclusions().size());

    art = dep.getArtifact();
    assertEquals("gid", art.getGroupId());
    assertEquals("aid", art.getArtifactId());
    assertEquals("ver3", art.getVersion());
    assertEquals("ext", art.getExtension());

    dep = deps.get(3);
    assertEquals("scope5", dep.getScope());
    assertEquals(true, dep.isOptional());
    assertEquals(0, dep.getExclusions().size());

    art = dep.getArtifact();
    assertEquals("gid1", art.getGroupId());
    assertEquals("aid", art.getArtifactId());
    assertEquals("ver", art.getVersion());
    assertEquals("ext", art.getExtension());
  }
 public File getLocation() {
   return artifact.getFile();
 }
 public String getVersion() {
   return artifact.getVersion();
 }
  @Test
  public void testDefaultArtifactString() {
    Artifact a;

    a = new DefaultArtifact("gid:aid:ver");
    assertEquals("gid", a.getGroupId());
    assertEquals("aid", a.getArtifactId());
    assertEquals("ver", a.getVersion());
    assertEquals("jar", a.getExtension());
    assertEquals("", a.getClassifier());

    a = new DefaultArtifact("gid:aid:ext:ver");
    assertEquals("gid", a.getGroupId());
    assertEquals("aid", a.getArtifactId());
    assertEquals("ver", a.getVersion());
    assertEquals("ext", a.getExtension());
    assertEquals("", a.getClassifier());

    a = new DefaultArtifact("gid:aid:ext:cls:ver");
    assertEquals("gid", a.getGroupId());
    assertEquals("aid", a.getArtifactId());
    assertEquals("ver", a.getVersion());
    assertEquals("ext", a.getExtension());
    assertEquals("cls", a.getClassifier());

    a = new DefaultArtifact("gid:aid::cls:ver");
    assertEquals("gid", a.getGroupId());
    assertEquals("aid", a.getArtifactId());
    assertEquals("ver", a.getVersion());
    assertEquals("jar", a.getExtension());
    assertEquals("cls", a.getClassifier());

    a = new DefaultArtifact(new DefaultArtifact("gid:aid:ext:cls:ver").toString());
    assertEquals("gid", a.getGroupId());
    assertEquals("aid", a.getArtifactId());
    assertEquals("ver", a.getVersion());
    assertEquals("ext", a.getExtension());
    assertEquals("cls", a.getClassifier());
  }
  /**
   * Creates a new class realm with the specified parent and imports.
   *
   * @param baseRealmId The base id to use for the new realm, must not be {@code null}.
   * @param type The type of the class realm, must not be {@code null}.
   * @param parent The parent realm for the new realm, may be {@code null} to use the Maven core
   *     realm.
   * @param imports The packages/types to import from the parent realm, may be {@code null}.
   * @param artifacts The artifacts to add to the realm, may be {@code null}. Unresolved artifacts
   *     (i.e. with a missing file) will automatically be excluded from the realm.
   * @return The created class realm, never {@code null}.
   */
  private ClassRealm createRealm(
      String baseRealmId,
      RealmType type,
      ClassLoader parent,
      List<String> imports,
      boolean importXpp3Dom,
      List<Artifact> artifacts) {
    Set<String> artifactIds = new LinkedHashSet<String>();

    List<ClassRealmConstituent> constituents = new ArrayList<ClassRealmConstituent>();

    if (artifacts != null) {
      for (Artifact artifact : artifacts) {
        artifactIds.add(getId(artifact));
        if (artifact.getFile() != null) {
          constituents.add(new ArtifactClassRealmConstituent(artifact));
        }
      }
    }

    if (imports != null) {
      imports = new ArrayList<String>(imports);
    } else {
      imports = new ArrayList<String>();
    }

    ClassRealm classRealm = newRealm(baseRealmId);

    if (parent != null) {
      classRealm.setParentClassLoader(parent);
    } else {
      classRealm.setParentRealm(getMavenRealm());
    }

    List<ClassRealmManagerDelegate> delegates = getDelegates();
    if (!delegates.isEmpty()) {
      ClassRealmRequest request = new DefaultClassRealmRequest(type, parent, imports, constituents);

      for (ClassRealmManagerDelegate delegate : delegates) {
        delegate.setupRealm(classRealm, request);
      }
    }

    if (importXpp3Dom) {
      importXpp3Dom(classRealm);
    }

    if (!imports.isEmpty()) {
      ClassLoader importedRealm = classRealm.getParentClassLoader();

      if (logger.isDebugEnabled()) {
        logger.debug("Importing packages into class realm " + classRealm.getId());
      }

      for (String imp : imports) {
        if (logger.isDebugEnabled()) {
          logger.debug("  Imported: " + imp);
        }

        classRealm.importFrom(importedRealm, imp);
      }
    }

    Set<String> includedIds = populateRealm(classRealm, constituents);

    if (logger.isDebugEnabled()) {
      artifactIds.removeAll(includedIds);

      for (String id : artifactIds) {
        logger.debug("  Excluded: " + id);
      }
    }

    return classRealm;
  }
  public void execute() throws MojoExecutionException, MojoFailureException {
    // set up derived paths
    forgeDir = new File(outputDir, "forge");
    jarsDir = new File(forgeDir, "mcp/jars");

    // check whether the artifact is already installed
    if (reinstall) {
      getLog().info("reinstall flag set; skipping availability check");
    } else {
      getLog().info("attempting to resolve Forge artifacts");

      if (null != resolveApiArtifact() && null != resolveToolsArtifact()) {
        getLog().info("artifacts are available; skipping installation");
        return;
      } else {
        getLog().info("artifacts not available; continuing installation");
      }
    }

    if (!noExtract) downloadAndExtract();

    if (!forgeDir.isDirectory())
      throw new MojoFailureException("distribution did not extract to the excpected directory");

    // run the install script
    if (!noInstall) {
      getLog().info("running install script");
      try {
        final PythonLauncher launcher = new PythonLauncher(getLog(), forgeDir);

        final int result = launcher.execute(new File(forgeDir, "install.py"));

        if (0 != result) {
          throw new MojoFailureException("install script returned " + result);
        }
      } catch (IOException caught) {
        throw new MojoFailureException("error calling install script", caught);
      }
    }

    // load Minecraft's POM
    final Model minecraft = loadModelFromResouce("minecraft.pom");
    minecraft.setVersion(getMinecraftVersion());

    // figure out Minecraft's dependencies
    {
      getLog().info("detecting Minecraft dependencies");
      final Artifact lwjgl =
          locator.findVersion(new File(jarsDir, "bin/lwjgl.jar"), "org.lwjgl.lwjgl", "lwjgl");

      final Artifact lwjgl_util =
          new DefaultArtifact("org.lwjgl.lwjgl", "lwjgl_util", "jar", lwjgl.getVersion());

      // don't include jinput.jar
      // it's a transitive dependency from LWJGL

      getLog().info("resolving Minecraft dependencies");
      for (Artifact target : new Artifact[] {lwjgl, lwjgl_util}) {
        getLog().info("    " + target);

        final Artifact resolved = resolveRemoteArtifact(target);
        if (null == resolved)
          throw new MojoFailureException("unable to resolve artifact " + target);

        minecraft.addDependency(artifactToDependency(resolved));
      }
    }

    // install Minecraft JAR
    installJar(minecraft, new File(jarsDir, "bin/minecraft.jar"));

    // figure out Forge's dependencies
    // using a Map of coordinates => artifact for deduplication
    // can't use a Set, Artifact#equals() doesn't behave
    final Map<String, Dependency> forgeDeps = new HashMap<String, Dependency>();
    for (File file : (new File(forgeDir, "mcp/lib")).listFiles()) {
      final Artifact artifact = locator.locate(file);
      if (null == artifact)
        throw new MojoFailureException("no artifact found for dependency " + file.getName());

      forgeDeps.put(artifact.toString(), artifactToDependency(artifact));
    }

    // add Minecraft client to Forge dependencies
    {
      final Artifact artifact =
          new DefaultArtifact("net.minecraft", "minecraft", "jar", getMinecraftVersion());
      forgeDeps.put(artifact.toString(), artifactToDependency(artifact));
    }

    // extract the Forge POM
    final File pom = new File(forgeDir, "pom.xml");
    {
      final Model model = loadModelFromResouce("mcforge.pom");
      model.setVersion(getApiDependency().getVersion());
      model.setDependencies(new ArrayList<Dependency>(forgeDeps.values()));
      writeModelToFile(model, pom);
    }

    // execute a build from the Forge POM
    getLog().info("executing POM to package and install artifacts");
    try {
      final MavenExecutionRequest request = new DefaultMavenExecutionRequest();
      requestPopulator.populateDefaults(request);

      request.setPom(pom);
      request.setGoals(Collections.singletonList("install"));

      final MavenExecutionResult result = maven.execute(request);

      // check for startup exceptions
      if (result.hasExceptions())
        throw new MojoFailureException(
            "failed to package and install artifacts", result.getExceptions().get(0));

      // check for build failure
      final BuildSummary summary = result.getBuildSummary(result.getProject());
      if (summary instanceof BuildFailure) {
        throw new MojoFailureException(
            "failed to package and install artifacts", ((BuildFailure) summary).getCause());
      }
    } catch (MojoFailureException caught) {
      throw caught;
    } catch (Exception caught) {
      throw new MojoFailureException("failed to package and install artifacts", caught);
    }
  }
 public String getArtifactId() {
   return artifact.getArtifactId();
 }
 public String getGroupId() {
   return artifact.getGroupId();
 }