Example #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);
    }
  }
Example #2
0
 @Override
 public boolean isInstalled() {
   Dependency dep = DependencyBuilder.create("org.jboss.seam.forge:forge-shell-api");
   PackagingType packagingType = project.getFacet(PackagingFacet.class).getPackagingType();
   return project.getFacet(DependencyFacet.class).hasDependency(dep)
       && PackagingType.JAR.equals(packagingType);
 }
Example #3
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;
  }
Example #4
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);
    }
  }
Example #5
0
  @Override
  public boolean install() {
    DependencyFacet deps = project.getFacet(DependencyFacet.class);

    List<Dependency> versions =
        deps.resolveAvailableVersions("org.jboss.seam.forge:forge-shell-api:[,]");
    Dependency version =
        shell.promptChoiceTyped("Install which version of the Forge API?", versions);
    deps.setProperty("forge.api.version", version.getVersion());
    DependencyBuilder dep =
        DependencyBuilder.create("org.jboss.seam.forge:forge-shell-api:${forge.api.version}");
    deps.addDependency(dep);
    return true;
  }
Example #6
0
  @Override
  public List<Dependency> resolveVersions(
      final Dependency dep, final List<DependencyRepository> repositories) {
    List<Dependency> result = new ArrayList<Dependency>();

    List<RemoteRepository> remoteRepos = convertToMavenRepos(repositories);
    VersionRangeResult r = getVersions(dep, remoteRepos);

    for (Version v : r.getVersions()) {
      result.add(DependencyBuilder.create(dep).setVersion(v.toString()));
    }

    return result;
  }
Example #7
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);
    }
  }
  @Override
  public List<MavenPlugin> listConfiguredPlugins() {
    MavenCoreFacet mavenCoreFacet = project.getFacet(MavenCoreFacet.class);
    List<Plugin> pomPlugins = mavenCoreFacet.getPOM().getBuild().getPlugins();
    List<MavenPlugin> plugins = new ArrayList<MavenPlugin>();

    for (Plugin plugin : pomPlugins) {
      MavenPluginAdapter adapter = new MavenPluginAdapter(plugin);
      MavenPluginBuilder pluginBuilder =
          MavenPluginBuilder.create()
              .setDependency(
                  DependencyBuilder.create()
                      .setGroupId(plugin.getGroupId())
                      .setArtifactId(plugin.getArtifactId())
                      .setVersion(plugin.getVersion()))
              .setConfiguration(adapter.getConfig());

      plugins.add(pluginBuilder);
    }

    return plugins;
  }
Example #9
0
/** @author <a href="mailto:[email protected]">Lincoln Baxter, III</a> */
@Alias("forge.spec.servlet")
@RequiresFacet({MetadataFacet.class, WebResourceFacet.class, DependencyFacet.class})
@RequiresPackagingType(PackagingType.WAR)
public class ServletFacet extends BaseFacet {

  private static final Dependency dep =
      DependencyBuilder.create("org.jboss.spec:jboss-javaee-6.0:1.0.0.Final:provided:basic");

  public WebAppDescriptor getConfig() {
    DescriptorImporter<WebAppDescriptor> importer = Descriptors.importAs(WebAppDescriptor.class);
    WebAppDescriptor descriptor = importer.from(getConfigFile().getResourceInputStream());
    return descriptor;
  }

  public void saveConfig(final WebAppDescriptor descriptor) {
    String output = descriptor.exportAsString();
    getConfigFile().setContents(output);
  }

  public FileResource<?> getConfigFile() {
    DirectoryResource webRoot = project.getFacet(WebResourceFacet.class).getWebRootDirectory();
    return (FileResource<?>) webRoot.getChild("WEB-INF" + File.separator + "web.xml");
  }

  /** List all servlet resource files. */
  public List<Resource<?>> getResources() {
    DirectoryResource webRoot = project.getFacet(WebResourceFacet.class).getWebRootDirectory();
    return listChildrenRecursively(webRoot);
  }

  private List<Resource<?>> listChildrenRecursively(DirectoryResource webRoot) {
    return listChildrenRecursively(
        webRoot,
        new ResourceFilter() {
          @Override
          public boolean accept(Resource<?> resource) {
            return true;
          }
        });
  }

  public List<Resource<?>> getResources(final ResourceFilter filter) {
    DirectoryResource webRoot = project.getFacet(WebResourceFacet.class).getWebRootDirectory();
    return listChildrenRecursively(webRoot, filter);
  }

  private List<Resource<?>> listChildrenRecursively(
      final DirectoryResource current, ResourceFilter filter) {
    List<Resource<?>> result = new ArrayList<Resource<?>>();
    List<Resource<?>> list = current.listResources();
    if (list != null) {
      for (Resource<?> file : list) {
        if (file instanceof DirectoryResource) {
          result.addAll(listChildrenRecursively((DirectoryResource) file, filter));
        }
        if (filter.accept(file)) result.add(file);
      }
    }
    return result;
  }

  /*
   * Facet Methods
   */
  @Override
  public boolean isInstalled() {
    DirectoryResource webRoot = project.getFacet(WebResourceFacet.class).getWebRootDirectory();
    return webRoot.exists()
        && getConfigFile().exists()
        && project.getFacet(DependencyFacet.class).hasDependency(dep);
  }

  @Override
  public boolean install() {
    if (!isInstalled()) {
      String projectName = project.getFacet(MetadataFacet.class).getProjectName();

      project.getFacet(DependencyFacet.class).addDependency(dep);

      DirectoryResource webRoot = project.getFacet(WebResourceFacet.class).getWebRootDirectory();
      if (!webRoot.exists()) {
        webRoot.mkdirs();
      }

      FileResource<?> descriptor = getConfigFile();
      if (!descriptor.exists()) {
        WebAppDescriptor unit =
            Descriptors.create(WebAppDescriptor.class)
                .displayName(projectName)
                .sessionTimeout(30)
                .welcomeFile("/index.html");

        descriptor.setContents(unit.exportAsString());
      }

      FileResource<?> welcomePage = (FileResource<?>) webRoot.getChild("index.html");
      welcomePage.setContents(
          "<html><head><title>Welcome to Seam Forge</title></head>"
              + "<body>"
              + "<h1> ["
              + projectName
              + "] is Online</h1>"
              + "Powered by <a href=\"http://bit.ly/seamforge\">Seam Forge</a>"
              + "</body>"
              + "</html>");
    }
    return true;
  }

  public static String mappingToRegex(String mapping) {
    return mapping
        .replaceAll("\\.", "\\.")
        .replaceAll("^\\*(.*)", "^(.*)$1\\$")
        .replaceAll("(.*)\\*$", "^$1(.*)\\$");
  }
}