Пример #1
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);
    }
  }
Пример #2
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();
    }
  }
  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);
    }
  }
  /** Verify operation manually. */
  public static void main(String[] args) throws Exception {

    final Logger log = logger();

    final RepositorySystem system = newSystem();

    final RepositorySystemSession session = newSession(system);

    // String uri = "jmock:jmock:pom:1.1.0";
    String uri = "org.apache.maven:maven-profile:2.2.1";

    final Artifact artifact = new DefaultArtifact(uri);

    final Dependency dependency = new Dependency(artifact, "compile");

    final RemoteRepository central = newRepoRemote();

    final CollectRequest collectRequest = new CollectRequest();
    collectRequest.setRoot(dependency);
    collectRequest.addRepository(central);

    final DependencyNode collectNode =
        system.collectDependencies(session, collectRequest).getRoot();

    final List<String> include = new ArrayList<String>();
    final List<String> exclude = new ArrayList<String>();

    final DependencyFilter filter = new ScopeDependencyFilter(include, exclude);

    final DependencyRequest dependencyRequest = new DependencyRequest(collectNode, filter);

    final DependencyResult result = system.resolveDependencies(session, dependencyRequest);

    final DependencyNode resolveNode = result.getRoot();

    final PreorderNodeListGenerator generator = new PreorderNodeListGenerator();

    resolveNode.accept(generator);

    final String[] pathArray = generator.getClassPath().split(File.pathSeparator);

    for (String path : pathArray) {
      log.info("path = " + path);
    }

    //

    final MavenProject project = newProject("org.apache.maven:maven-model:pom:3.0");

    log.info("project = " + project);
  }
  public static void main(String[] args) throws Exception {

    final String uri = "com.carrotgarden.osgi:carrot-osgi-anno-scr-make:jar:1.1.3";

    final Artifact artifact = new DefaultArtifact(uri);

    Dependency dependency = new Dependency(artifact, "compile");

    CollectRequest collectRequest = new CollectRequest(dependency, null);

    RepositorySystem system = UnitHelp.newSystem();

    MavenRepositorySystemSession session = UnitHelp.newSession(system);

    session.setOffline(true);

    Collection<String> scopeIncluded = new ArrayList<String>();
    Collection<String> scopeExcluded = new ArrayList<String>();

    scopeIncluded.add("provided");

    scopeExcluded.add("test");

    session.setDependencySelector( //
        new AndDependencySelector( //
            new OptionalDependencySelector(), //
            new ScopeDependencySelector(scopeIncluded, scopeExcluded), //
            new ExclusionDependencySelector()) //
        );

    CollectResult collectResult = system.collectDependencies(session, collectRequest);

    DependencyNode collectNode = collectResult.getRoot();

    final DependencyRequest dependencyRequest = new DependencyRequest(collectNode, null);

    final DependencyResult result = system.resolveDependencies(session, dependencyRequest);

    final DependencyNode resolveNode = result.getRoot();

    final PreorderNodeListGenerator generator = new PreorderNodeListGenerator();

    resolveNode.accept(generator);

    List<Artifact> list = generator.getArtifacts(true);

    for (Artifact item : list) {
      System.out.println("item = " + item);
    }
  }
  /** Resolve maven URI into maven artifact. */
  public static Artifact newArtifact(String mavenURI) throws Exception {

    final RepositorySystem system = newSystem();
    final RepositorySystemSession session = newSession(system);
    final RemoteRepository central = newRepoRemote();

    final ArtifactRequest request = new ArtifactRequest();
    request.setArtifact(new DefaultArtifact(mavenURI));
    request.addRepository(central);

    final ArtifactResult result = system.resolveArtifact(session, request);

    final Artifact artifact = result.getArtifact();

    return artifact;
  }
  public RepositorySystemSession newSystemSession(RepositorySystem sys, Settings settings) {
    DefaultRepositorySystemSession session = new MavenRepositorySystemSession();

    Map<String, Object> configProps = new LinkedHashMap<String, Object>();
    putAllEnvProperties(configProps);
    session.setConfigProperties(configProps);

    session.setOffline(settings.isOffline());
    // session.setUserProperties(settings.getUserProperties());

    LocalRepository localRepo = new LocalRepository(getDefaultLocalRepoDir(settings));
    session.setLocalRepositoryManager(sys.newLocalRepositoryManager(localRepo));

    // session.setProxySelector(getProxySelector());
    session.setMirrorSelector(getMirrorSelector(settings));
    // session.setAuthenticationSelector(getAuthSelector());

    session.setCache(new DefaultRepositoryCache());

    // session.setRepositoryListener(new AntRepositoryListener(task));

    // session.setWorkspaceReader(ProjectWorkspaceReader.getInstance());

    return session;
  }
Пример #8
0
  @Override
  public List<DependencyResource> resolveArtifacts(
      Dependency dep, final List<DependencyRepository> repositories) {
    List<DependencyResource> result = new ArrayList<DependencyResource>();

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

      session.setIgnoreInvalidArtifactDescriptor(true);
      session.setIgnoreMissingArtifactDescriptor(true);

      VersionRangeResult versions = getVersions(dep, convertToMavenRepos(repositories));

      VERSION:
      for (Version version : versions.getVersions()) {
        ArtifactRequest request = new ArtifactRequest();
        ArtifactRepository ar = versions.getRepository(version);
        if (ar instanceof RemoteRepository) {
          RemoteRepository remoteRepo =
              new RemoteRepository(
                  ar.getId(), ar.getContentType(), ((RemoteRepository) ar).getUrl());
          request.addRepository(remoteRepo);
          DependencyBuilder currentVersion =
              DependencyBuilder.create(dep).setVersion(version.toString());
          request.setArtifact(new DefaultArtifact(currentVersion.toCoordinates()));

          try {
            ArtifactResult a = system.resolveArtifact(session, request);

            File file = a.getArtifact().getFile();
            DependencyResource resource = new DependencyResource(factory, file, currentVersion);
            if (!result.contains(resource)) {
              result.add(resource);
              continue VERSION;
            }
          } catch (ArtifactResolutionException e) {
            System.out.println(e.getMessage());
          }
        }
      }
    } catch (ComponentLookupException e) {
      throw new ProjectModelException("Error in dependency resolution container", e);
    }
    return result;
  }
  /** Default repository session. */
  public static MavenRepositorySystemSession newSession(RepositorySystem system) throws Exception {

    final LocalRepository localRepo = newRepoLocal();

    final MavenRepositorySystemSession session = new MavenRepositorySystemSession();

    session.setLocalRepositoryManager(system.newLocalRepositoryManager(localRepo));

    return session;
  }
Пример #10
0
  private MavenRepositorySystemSession setupRepoSession(RepositorySystem repoSystem) {
    MavenRepositorySystemSession session = new MavenRepositorySystemSession();

    LocalRepository localRepo =
        new LocalRepository(OSUtils.getUserHomeDir().getAbsolutePath() + "/.m2/repository");
    session.setLocalRepositoryManager(repoSystem.newLocalRepositoryManager(localRepo));
    session.setOffline(false);

    session.setTransferErrorCachingEnabled(false);
    session.setNotFoundCachingEnabled(false);
    return session;
  }
Пример #11
0
  public void execute() throws MojoExecutionException, MojoFailureException {
    try {
      ArtifactDescriptorResult artifactDescriptor =
          repoSystem.readArtifactDescriptor(
              repoSession,
              new ArtifactDescriptorRequest(new DefaultArtifact(artifact), projectRepos, null));

      CollectRequest collectRequest = new CollectRequest();
      collectRequest.setDependencies(artifactDescriptor.getDependencies());
      collectRequest.setManagedDependencies(artifactDescriptor.getManagedDependencies());
      collectRequest.setRepositories(projectRepos);

      CollectResult dependencies = repoSystem.collectDependencies(repoSession, collectRequest);

      StringWriter writer = new StringWriter();
      NodeFormatter nodeFormatter =
          new DefaultNodeFormatter(artifactDescriptor.getArtifact().toString());
      dependencies
          .getRoot()
          .accept(
              new SerializingDependencyVisitor(
                  writer, SerializingDependencyVisitor.STANDARD_TOKENS, nodeFormatter));

      try {
        if (outputFile == null) {
          log(writer.toString(), getLog());
        } else {
          write(writer.toString(), outputFile);
          getLog().info("Wrote dependency tree to: " + outputFile);
        }
      } catch (IOException e) {
        throw new MojoExecutionException("Failed to write dependencies to file", e);
      }
    } catch (ArtifactDescriptorException e) {
      throw new MojoExecutionException("Failed to read artifact descriptor", e);
    } catch (DependencyCollectionException e) {
      throw new MojoExecutionException("Failed to collect dependencies", e);
    }
  }
Пример #12
0
  private VersionRangeResult getVersions(
      Dependency dep, final List<RemoteRepository> repositories) {
    try {
      String version = dep.getVersion();
      if (Strings.isNullOrEmpty(version)) {
        dep = DependencyBuilder.create(dep).setVersion("[,)");
      } else if (!version.matches("(\\(|\\[).*?(\\)|\\])")) {
        dep = DependencyBuilder.create(dep).setVersion("[" + version + "]");
      }

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

      VersionRangeRequest rangeRequest =
          new VersionRangeRequest(new DefaultArtifact(dep.toCoordinates()), repositories, null);

      VersionRangeResult rangeResult = maven.resolveVersionRange(session, rangeRequest);
      return rangeResult;
    } catch (Exception e) {
      throw new ProjectModelException("Failed to look up versions for [" + dep + "]", e);
    }
  }
Пример #13
0
  public boolean contains(String groupId, String artifactId, String version, String type) {
    Artifact artifact = new DefaultArtifact(groupId, artifactId, type, version);

    try {
      repositorySystem.resolveArtifact(
          session,
          new ArtifactRequest(
              artifact, ImmutableList.of(snapshotsRepository, releasesRepository), null));
    } catch (ArtifactResolutionException e) {
      return false;
    }

    return true;
  }
Пример #14
0
  @Override
  public List<DependencyResource> resolveDependencies(
      Dependency dep, final List<DependencyRepository> repositories) {
    List<DependencyResource> result = new ArrayList<DependencyResource>();

    try {
      if (Strings.isNullOrEmpty(dep.getVersion())) {
        dep = DependencyBuilder.create(dep).setVersion("[,)");
      }

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

      DefaultArtifact artifact = new DefaultArtifact(dep.toCoordinates());
      CollectRequest collectRequest =
          new CollectRequest(
              new org.sonatype.aether.graph.Dependency(artifact, null),
              convertToMavenRepos(repositories));
      DependencyRequest request = new DependencyRequest(collectRequest, null);

      DependencyResult artifacts = system.resolveDependencies(session, request);

      for (ArtifactResult a : artifacts.getArtifactResults()) {
        File file = a.getArtifact().getFile();
        Dependency d =
            DependencyBuilder.create()
                .setArtifactId(a.getArtifact().getArtifactId())
                .setGroupId(a.getArtifact().getGroupId())
                .setVersion(a.getArtifact().getVersion());
        DependencyResource resource = new DependencyResource(factory, file, d);
        result.add(resource);
      }
      return result;
    } catch (Exception e) {
      throw new ProjectModelException("Unable to resolve an artifact", e);
    }
  }
Пример #15
0
  public AetherResult resolve(
      String groupId, String artifactId, String version, String extension, String classifier)
      throws PlexusContainerException, ComponentLookupException, DependencyCollectionException,
          ArtifactResolutionException, DependencyResolutionException {
    if (Strings.isBlank(extension) || extension.equals("bundle")) {
      extension = DEFAULT_EXTENSION;
    }
    if (classifier == null) {
      classifier = DEFAULT_CLASSIFIER;
    }

    RepositorySystemSession session = newSession();
    Dependency dependency =
        new Dependency(
            new DefaultArtifact(groupId, artifactId, classifier, extension, version), "runtime");

    CollectRequest collectRequest = new CollectRequest();
    collectRequest.setRoot(dependency);

    List<RemoteRepository> repos = getRemoteRepositories();
    RemoteRepository[] repoArray = new RemoteRepository[repos.size()];
    repos.toArray(repoArray);
    for (RemoteRepository repo : repoArray) {
      collectRequest.addRepository(repo);
    }
    RepositorySystem system = getRepositorySystem();
    DependencyNode rootNode = system.collectDependencies(session, collectRequest).getRoot();
    DependencyRequest dependencyRequest = new DependencyRequest();
    dependencyRequest.setRoot(rootNode);
    system.resolveDependencies(session, dependencyRequest);

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

    return new AetherResult(rootNode, nlg.getFiles(), nlg.getClassPath());
  }
Пример #16
0
  public Maven(
      @Nullable Metadata.Repository snapshotsRepositoryInfo,
      @Nullable Metadata.Repository releasesRepositoryInfo)
      throws SettingsBuildingException {
    validateRepositoryMetadata(snapshotsRepositoryInfo, "snapshots");
    validateRepositoryMetadata(releasesRepositoryInfo, "releases");

    final SettingsBuildingRequest request =
        new DefaultSettingsBuildingRequest()
            .setGlobalSettingsFile(DEFAULT_GLOBAL_SETTINGS_FILE)
            .setUserSettingsFile(DEFAULT_USER_SETTINGS_FILE)
            .setSystemProperties(System.getProperties());

    Settings settings =
        new DefaultSettingsBuilderFactory().newInstance().build(request).getEffectiveSettings();

    repositorySystem =
        new DefaultServiceLocator()
            .addService(RepositoryConnectorFactory.class, AsyncRepositoryConnectorFactory.class)
            .addService(RepositoryConnectorFactory.class, FileRepositoryConnectorFactory.class)
            .addService(VersionResolver.class, DefaultVersionResolver.class)
            .addService(VersionRangeResolver.class, DefaultVersionRangeResolver.class)
            .addService(ArtifactDescriptorReader.class, DefaultArtifactDescriptorReader.class)
            .addService(MetadataGeneratorFactory.class, SnapshotMetadataGeneratorFactory.class)
            .getService(RepositorySystem.class);

    String localRepository = settings.getLocalRepository();
    if (localRepository == null || localRepository.trim().isEmpty()) {
      localRepository = new File(MAVEN_USER_HOME, "repository").getAbsolutePath();
    }

    session =
        new MavenRepositorySystemSession()
            .setLocalRepositoryManager(
                repositorySystem.newLocalRepositoryManager(new LocalRepository(localRepository)));

    releasesRepository =
        makeRemoteRepository(
            releasesRepositoryInfo, settings.getServer(releasesRepositoryInfo.getId()), false);
    snapshotsRepository =
        makeRemoteRepository(
            snapshotsRepositoryInfo, settings.getServer(snapshotsRepositoryInfo.getId()), true);
  }
Пример #17
0
  private List<Artifact> resolveArtifacts(DependencyRequest dependencyRequest) {
    DependencyResult dependencyResult;
    try {
      dependencyResult =
          repositorySystem.resolveDependencies(repositorySystemSession, dependencyRequest);
    } catch (DependencyResolutionException e) {
      dependencyResult = e.getResult();
    }
    List<ArtifactResult> artifactResults = dependencyResult.getArtifactResults();
    List<Artifact> artifacts = new ArrayList<>(artifactResults.size());
    for (ArtifactResult artifactResult : artifactResults) {
      if (artifactResult.isMissing()) {
        artifacts.add(artifactResult.getRequest().getArtifact());
      } else {
        artifacts.add(artifactResult.getArtifact());
      }
    }

    return Collections.unmodifiableList(artifacts);
  }
  @Override
  public BundleInformation installFromRepository(String featureId, boolean start) {

    org.apache.maven.repository.internal.DefaultServiceLocator locator =
        new org.apache.maven.repository.internal.DefaultServiceLocator();
    locator.addService(RepositoryConnectorFactory.class, WagonRepositoryConnectorFactory.class);
    locator.setServices(WagonProvider.class, new HttpWagonProvider());

    RepositorySystem system = locator.getService(RepositorySystem.class);

    // RepositorySystem system = null;
    try {
      // system = new DefaultPlexusContainer().lookup(RepositorySystem.class);

      MavenRepositorySystemSession mvnRepository = new MavenRepositorySystemSession();

      mvnRepository.setLocalRepositoryManager(
          system.newLocalRepositoryManager(
              new LocalRepository(System.getProperty("java.io.tmpdir") + "/repo")));

      CollectRequest collectRequest = new CollectRequest();
      collectRequest.setRoot(new Dependency(new DefaultArtifact(featureId), JavaScopes.RUNTIME));
      collectRequest.addRepository(
          new RemoteRepository(
              "central", "default", "http://nexus.motechproject.org/content/repositories/public"));

      DependencyRequest dependencyRequest =
          new DependencyRequest(
              collectRequest, DependencyFilterUtils.classpathFilter(JavaScopes.RUNTIME));

      BundleInformation bundleInformation = null;
      List<ArtifactResult> artifactResults =
          system.resolveDependencies(mvnRepository, dependencyRequest).getArtifactResults();

      List<Bundle> bundlesInstalled = new ArrayList<>();

      for (ArtifactResult artifact : artifactResults) {
        LOG.info("Installing " + artifact);
        final File bundleFile = artifact.getArtifact().getFile();
        FileInputStream fileInputStream = null;
        try {
          fileInputStream = new FileInputStream(bundleFile);
          final File bundleFileToInstall =
              bundleDirectoryManager.saveBundleStreamToFile(bundleFile.getName(), fileInputStream);
          final Bundle bundle = installBundleFromFile(bundleFileToInstall, false, false);
          if (bundle != null) {
            bundlesInstalled.add(bundle);
          }
        } finally {
          IOUtils.closeQuietly(fileInputStream);
        }
      }

      // start bundles after all bundles installed to avoid any dependency resolution problems.
      if (start) {
        for (Bundle bundle : bundlesInstalled) {
          if (!isFragmentBundle(bundle)) {
            bundle.start();
          }
        }
      }

      return bundleInformation;
    } catch (Exception e) {
      LOG.error("Error while installing bundle and dependencies " + featureId, e);
      throw new MotechException("Cannot install file", e);
    }
  }
  @Override
  public void execute() throws MojoExecutionException {

    Path warExecFile = Paths.get(buildDirectory, finalName);
    try {
      Files.deleteIfExists(warExecFile);
      Files.createDirectories(warExecFile.getParent());

      try (OutputStream os = Files.newOutputStream(warExecFile);
          ArchiveOutputStream aos =
              new ArchiveStreamFactory().createArchiveOutputStream(ArchiveStreamFactory.JAR, os)) {

        // If project is a war project add the war to the project
        if ("war".equalsIgnoreCase(project.getPackaging())) {
          File projectArtifact = project.getArtifact().getFile();
          if (projectArtifact != null && Files.exists(projectArtifact.toPath())) {
            aos.putArchiveEntry(new JarArchiveEntry(projectArtifact.getName()));
            try (InputStream is = Files.newInputStream(projectArtifact.toPath())) {
              IOUtils.copy(is, aos);
            }
            aos.closeArchiveEntry();
          }
        }

        // Add extraWars into the jar
        if (extraWars != null) {
          for (Dependency extraWarDependency : extraWars) {
            ArtifactRequest request = new ArtifactRequest();
            request.setArtifact(
                new DefaultArtifact(
                    extraWarDependency.getGroupId(),
                    extraWarDependency.getArtifactId(),
                    extraWarDependency.getType(),
                    extraWarDependency.getVersion()));
            request.setRepositories(projectRepos);
            ArtifactResult result;
            try {
              result = repoSystem.resolveArtifact(repoSession, request);
            } catch (ArtifactResolutionException e) {
              throw new MojoExecutionException(e.getMessage(), e);
            }

            File extraWarFile = result.getArtifact().getFile();
            aos.putArchiveEntry(new JarArchiveEntry(extraWarFile.getName()));
            try (InputStream is = Files.newInputStream(extraWarFile.toPath())) {
              IOUtils.copy(is, aos);
            }
            aos.closeArchiveEntry();
          }
        }

        // Add extraResources into the jar. Folder /extra
        if (extraResources != null) {
          for (Resource extraResource : extraResources) {
            DirectoryScanner directoryScanner = new DirectoryScanner();
            directoryScanner.setBasedir(extraResource.getDirectory());

            directoryScanner.setExcludes(
                extraResource
                    .getExcludes()
                    .toArray(new String[extraResource.getExcludes().size()]));

            if (!extraResource.getIncludes().isEmpty()) {
              directoryScanner.setIncludes(
                  extraResource
                      .getIncludes()
                      .toArray(new String[extraResource.getIncludes().size()]));
            } else {
              // include everything by default
              directoryScanner.setIncludes(new String[] {"**"});
            }

            directoryScanner.scan();
            for (String includeFile : directoryScanner.getIncludedFiles()) {
              aos.putArchiveEntry(
                  new JarArchiveEntry(Runner.EXTRA_RESOURCES_DIR + "/" + includeFile));

              Path extraFile = Paths.get(extraResource.getDirectory(), includeFile);
              try (InputStream is = Files.newInputStream(extraFile)) {
                IOUtils.copy(is, aos);
              }
              aos.closeArchiveEntry();
            }
          }
        }

        Set<String> includeArtifacts = new HashSet<>();
        includeArtifacts.add("org.apache.tomcat:tomcat-jdbc");
        includeArtifacts.add("org.apache.tomcat.embed:tomcat-embed-core");
        includeArtifacts.add("org.apache.tomcat.embed:tomcat-embed-logging-juli");
        includeArtifacts.add("org.yaml:snakeyaml");
        includeArtifacts.add("com.beust:jcommander");

        if (includeJSPSupport) {
          includeArtifacts.add("org.apache.tomcat.embed:tomcat-embed-jasper");
          includeArtifacts.add("org.eclipse.jdt.core.compiler:ecj");
        }

        for (Artifact pluginArtifact : pluginArtifacts) {
          String artifactName = pluginArtifact.getGroupId() + ":" + pluginArtifact.getArtifactId();
          if (includeArtifacts.contains(artifactName)) {
            try (JarFile jarFile = new JarFile(pluginArtifact.getFile())) {
              extractJarToArchive(jarFile, aos);
            }
          }
        }

        if (extraDependencies != null) {
          for (Dependency dependency : extraDependencies) {

            ArtifactRequest request = new ArtifactRequest();
            request.setArtifact(
                new DefaultArtifact(
                    dependency.getGroupId(),
                    dependency.getArtifactId(),
                    dependency.getType(),
                    dependency.getVersion()));
            request.setRepositories(projectRepos);
            ArtifactResult result;
            try {
              result = repoSystem.resolveArtifact(repoSession, request);
            } catch (ArtifactResolutionException e) {
              throw new MojoExecutionException(e.getMessage(), e);
            }

            try (JarFile jarFile = new JarFile(result.getArtifact().getFile())) {
              extractJarToArchive(jarFile, aos);
            }
          }
        }

        if (includeJSPSupport) {
          addFile(aos, "/conf/web.xml", "conf/web.xml");
        } else {
          addFile(aos, "/conf/web_wo_jsp.xml", "conf/web.xml");
        }
        addFile(aos, "/conf/logging.properties", "conf/logging.properties");

        if (includeTcNativeWin32 != null) {
          aos.putArchiveEntry(new JarArchiveEntry("tcnative-1.dll.32"));
          Files.copy(Paths.get(includeTcNativeWin32), aos);
          aos.closeArchiveEntry();
        }

        if (includeTcNativeWin64 != null) {
          aos.putArchiveEntry(new JarArchiveEntry("tcnative-1.dll.64"));
          Files.copy(Paths.get(includeTcNativeWin64), aos);
          aos.closeArchiveEntry();
        }

        String[] runnerClasses = {
          "ch.rasc.embeddedtc.runner.CheckConfig$CheckConfigOptions",
          "ch.rasc.embeddedtc.runner.CheckConfig",
          "ch.rasc.embeddedtc.runner.Config",
          "ch.rasc.embeddedtc.runner.Shutdown",
          "ch.rasc.embeddedtc.runner.Context",
          "ch.rasc.embeddedtc.runner.DeleteDirectory",
          "ch.rasc.embeddedtc.runner.ObfuscateUtil$ObfuscateOptions",
          "ch.rasc.embeddedtc.runner.ObfuscateUtil",
          "ch.rasc.embeddedtc.runner.Runner$1",
          "ch.rasc.embeddedtc.runner.Runner$2",
          "ch.rasc.embeddedtc.runner.Runner$StartOptions",
          "ch.rasc.embeddedtc.runner.Runner$StopOptions",
          "ch.rasc.embeddedtc.runner.Runner$RunnerShutdownHook",
          "ch.rasc.embeddedtc.runner.Runner"
        };

        for (String rc : runnerClasses) {
          String classAsPath = rc.replace('.', '/') + ".class";

          try (InputStream is = getClass().getResourceAsStream("/" + classAsPath)) {
            aos.putArchiveEntry(new JarArchiveEntry(classAsPath));
            IOUtils.copy(is, aos);
            aos.closeArchiveEntry();
          }
        }

        Manifest manifest = new Manifest();

        Manifest.Attribute mainClassAtt = new Manifest.Attribute();
        mainClassAtt.setName("Main-Class");
        mainClassAtt.setValue(Runner.class.getName());
        manifest.addConfiguredAttribute(mainClassAtt);

        aos.putArchiveEntry(new JarArchiveEntry("META-INF/MANIFEST.MF"));
        manifest.write(aos);
        aos.closeArchiveEntry();

        aos.putArchiveEntry(new JarArchiveEntry(Runner.TIMESTAMP_FILENAME));
        aos.write(String.valueOf(System.currentTimeMillis()).getBytes(StandardCharsets.UTF_8));
        aos.closeArchiveEntry();
      }
    } catch (IOException | ArchiveException | ManifestException e) {
      throw new MojoExecutionException(e.getMessage(), e);
    }
  }