org.apache.maven.model.Repository Java Examples

/**
 * Dynamically add project repositories based on different configuration sources such as environment variables,
 * system properties configuration files.
 */
private List<Repository> loadDynamicRepositories() {
    if (repositoryList == null) {
        repositoryList = new ArrayList<>();
        logger.info("Add dynamic project repositories ...");

        try {
            repositoryList.addAll(new FileBasedRepositoryLoader().load(logger));
            repositoryList.addAll(new SystemPropertyRepositoryLoader().load(logger));
            repositoryList.addAll(new EnvironmentSettingRepositoryLoader().load(logger));
        } catch (LifecycleExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    return repositoryList;
}
 

/**
 * Verify that default mock repositories are present in the given list od repositories. This verification can be shared by multiple
 * tests that load the repository list in different ways (e.g. via Json, Yaml, System properties, ...)
 * @param repositoryList
 */
public static void verifyRepositories(List<Repository> repositoryList) {
    Repository central = new Repository();
    central.setId("central");
    central.setName("Maven Central");
    central.setUrl("https://repo.maven.apache.org/maven2/");

    Repository jboss = new Repository();
    jboss.setId("jboss-ea");
    jboss.setName("JBoss Community Early Access Release Repository");
    jboss.setUrl("https://repository.jboss.org/nexus/content/groups/ea/");

    Assertions.assertThat(repositoryList).hasSize(2);
    Assertions.assertThat(repositoryList).anyMatch(repository -> repository.getId().equals(central.getId()));
    Assertions.assertThat(repositoryList).anyMatch(repository -> repository.getUrl().equals(central.getUrl()));
    Assertions.assertThat(repositoryList).anyMatch(repository -> repository.getId().equals(jboss.getId()));
    Assertions.assertThat(repositoryList).anyMatch(repository -> repository.getUrl().equals(jboss.getUrl()));
}
 

/**
 * Examine the repository to see if we should not remove it.
 * @param state to query the ignoreLocal value
 * @param repo the repository to examine
 * @return boolean whether to remove this repository
 */
private boolean removeRepository (RepoReportingState state, Repository repo)
{
    boolean result = true;

    if (state.ignoreLocal())
    {
        String url = repo.getUrl();
        // According to https://maven.apache.org/plugins/maven-site-plugin/examples/adding-deploy-protocol.html
        // supported repositories are file, http and https.
        if (url.startsWith( "file:" ) ||
            url.startsWith( "http://localhost" ) ||
            url.startsWith( "https://localhost" ) ||
            url.startsWith( "http://127.0.0.1" ) ||
            url.startsWith( "https://127.0.0.1" ) ||
            url.startsWith( "http://::1" ) ||
            url.startsWith( "https://::1" ) )
        {
            result = false;
        }
    }
    return result;
}
 

private static SortedSet<DefaultArtifactVersion> resolveVersions(final MavenProject project, final Log log, final ResolvableDependency dependency) throws MojoExecutionException {
  final List<Repository> repositories = project.getRepositories();
  final SortedSet<DefaultArtifactVersion> allVersions = new TreeSet<>();
  for (final Repository repository : repositories) {
    final DependencyId dependencyId = new DependencyId(dependency, repository);
    final SortedSet<DefaultArtifactVersion> versions;
    if (dependencyIdToVersions.containsKey(dependencyId))
      versions = dependencyIdToVersions.get(dependencyId);
    else
      dependencyIdToVersions.put(dependencyId, versions = downloadVersions(log, dependencyId));

    if (versions != null)
      allVersions.addAll(versions);
  }

  if (allVersions.size() == 0)
    throw new MojoExecutionException("Artifact " + dependency.getGroupId() + ":" + dependency.getArtifactId() + " was not found in any repositories:\n" + AssembleUtil.toIndentedString(repositories));

  return allVersions;
}
 

/**
 * Add the repository to the list of repositories. If an existing repository has the same
 * id it is removed first.
 *
 * @param repositories the current list of repositories
 * @param repository the repository to add
 */
private void addRepository( final List<Repository> repositories, final Repository repository )
{
    final Iterator<Repository> i = repositories.iterator();
    while ( i.hasNext() )
    {
        final Repository r = i.next();

        if ( repository.getId().equals( r.getId() ) )
        {
            logger.debug("Removing local repository {} ", r);
            i.remove();
            break;
        }
    }

    logger.debug( "Adding repository {}", repository );
    repositories.add(repository);
}
 

@Override
public void addRepository(final Repository repository, boolean replace) throws InvalidRepositoryException
{
   if (session.isIgnoreArtifactDescriptorRepositories())
   {
      return;
   }

   if (!repositoryIds.add(repository.getId()))
   {
      if (!replace)
      {
         return;
      }

      removeMatchingRepository(repository.getId());
   }
   repositories.add(new RemoteRepository.Builder(repository.getId(), repository.getName(), repository.getUrl())
            .build());
}
 

/**
 * Construct repository instance from given url. Query parameters are translated to fields on the target repository.
 * @param id
 * @param url
 * @param logger
 * @return
 */
default Repository build(String id, String url, Logger logger) throws LifecycleExecutionException {
    Repository repository = new Repository();

    repository.setId(id);

    try {
        URL configurationUrl = new URL(url);
        repository.setUrl(String.format("%s://%s%s", configurationUrl.getProtocol(), configurationUrl.getHost(), configurationUrl.getPath()));
    } catch (MalformedURLException e) {
        throw new LifecycleExecutionException("Failed to construct Maven repository model from given URL", e);
    }

    logger.info(String.format("Add Repository %s=%s", repository.getId(), repository.getUrl()));
    return repository;
}
 

/**
 * This method determines if the given {@link Repository} section is identical to what is defined from the super
 * POM.
 *
 * @param repo is the {@link Repository} section to check.
 * @return <code>true</code> if maven central default configuration, <code>false</code> otherwise.
 */
private static boolean isCentralRepositoryFromSuperPom( Repository repo )
{
    if ( repo != null )
    {
        if ( "central".equals( repo.getId() ) )
        {
            RepositoryPolicy snapshots = repo.getSnapshots();
            if ( snapshots != null && !snapshots.isEnabled() )
            {
                return true;
            }
        }
    }
    return false;
}
 

/**
 * Creates a flattened {@link List} of {@link Repository} elements where those from super-POM are omitted.
 *
 * @param repositories is the {@link List} of {@link Repository} elements. May be <code>null</code>.
 * @return the flattened {@link List} of {@link Repository} elements or <code>null</code> if <code>null</code> was
 *         given.
 */
protected static List<Repository> createFlattenedRepositories( List<Repository> repositories )
{
    if ( repositories != null )
    {
        List<Repository> flattenedRepositories = new ArrayList<Repository>( repositories.size() );
        for ( Repository repo : repositories )
        {
            // filter inherited repository section from super POM (see MOJO-2042)...
            if ( !isCentralRepositoryFromSuperPom( repo ) )
            {
                flattenedRepositories.add( repo );
            }
        }
        return flattenedRepositories;
    }
    return repositories;
}
 

@Override
public List<Repository> load(Logger logger) throws LifecycleExecutionException {
    List<Repository> repositoryList = new ArrayList<>();

    String coordinates = System.getProperty(ExtensionSettings.REPOSITORIES_SETTING_KEY, "");

    if (coordinates.length() > 0) {
        for (String scalar : coordinates.split(",")) {
            String[] config = scalar.split("=");
            if (config.length == 2) {
                repositoryList.add(build(config[0], config[1], logger));
            }
        }

        if (!repositoryList.isEmpty()) {
            logger.info(String.format("Add %s repositories found in system properties", repositoryList.size()));
        }
    }

    return repositoryList;
}
 

@Override
public List<Repository> load(Logger logger) throws LifecycleExecutionException {
    List<Repository> repositoryList = new ArrayList<>();

    String settings = getEnvSetting(ExtensionSettings.REPOSITORIES_SETTING_ENV);

    if (settings.length() > 0) {
        for (String scalar : settings.split(",")) {
            String[] config = scalar.split("=");
            if (config.length == 2) {
                repositoryList.add(build(config[0], config[1], logger));
            }
        }

        if (!repositoryList.isEmpty()) {
            logger.info(String.format("Add %s repositories found in environment variables", repositoryList.size()));
        }
    }

    return repositoryList;
}
 

@Override
public void addRepository(Repository repository) throws InvalidRepositoryException
{
   if (repositoryIds.contains(repository.getId()))
   {
      return;
   }

   repositoryIds.add(repository.getId());
   repositories.add(new RemoteRepository.Builder(repository.getId(), repository.getName(), repository.getUrl())
            .build());
}
 

/** Adds a user-specified repository to the list. */
public void addUserRepository(String url) {
  Repository repository = new Repository();
  repository.setUrl(url);
  repository.setId("user-defined repository");
  repository.setName("default");
  addRepository(repository);
  this.aether.addRemoteRepository(
      new RemoteRepository.Builder("user-defined repository", "default", url).build());
}
 

@Test
public void shouldLoadFromPropertyFile() throws LifecycleExecutionException {
    System.setProperty(ExtensionSettings.SETTINGS_FILE_KEY, "classpath:yaks.properties");
    List<Repository> repositoryList = loader.load(logger);
    TestHelper.verifyRepositories(repositoryList);

    System.setProperty(ExtensionSettings.SETTINGS_FILE_KEY, "classpath:yaks.settings.yaml");
    repositoryList = loader.load(logger);
    TestHelper.verifyRepositories(repositoryList);

    System.setProperty(ExtensionSettings.SETTINGS_FILE_KEY, "classpath:yaks.settings.json");
    repositoryList = loader.load(logger);
    TestHelper.verifyRepositories(repositoryList);
}
 

@Test
public void shouldLoadFromEnv() throws LifecycleExecutionException {
    EnvironmentSettingRepositoryLoader loader = new EnvironmentSettingRepositoryLoader() {
        @Override
        protected String getEnvSetting(String name) {
            return "central=https://repo.maven.apache.org/maven2/,jboss-ea=https://repository.jboss.org/nexus/content/groups/ea/";
        }
    };

    List<Repository> repositoryList = loader.load(logger);
    TestHelper.verifyRepositories(repositoryList);
}
 

MavenArtifactResolver(List<Repository> repositories) {
    this.repositorySystem = createRepositorySystem();
    this.remoteRepositories = new LinkedList<>();
    repositories.forEach(r -> {
        RemoteRepository repository = new RemoteRepository
                .Builder(r.getId(), "default", r.getUrl())
                .build();
        remoteRepositories.add(repository);
    });
}
 

public static Map<String, Artifact> findArtifactsForTarget(List<Dependency> dependencies, List<Repository> repositories, String target) {
    final MavenArtifactResolver resolver = new MavenArtifactResolver(repositories);
    return dependencies.stream()
            .filter(d -> DEPENDENCY_GROUP.equals(d.getGroupId()))
            .map(d -> {
                if (UTIL_ARTIFACT.equals(d.getArtifactId())) {
                    if (Constants.PROFILE_ANDROID.equals(target) ||
                        Constants.PROFILE_IOS.equals(target)||
                        Constants.PROFILE_IOS_SIM.equals(target)) {
                        return new DefaultArtifact(d.getGroupId(), d.getArtifactId(),
                                target, d.getType(), d.getVersion());
                    }
                    return  null;
                }
                AttachServiceDefinition asd = new AttachServiceDefinition(d.getArtifactId());
                return new DefaultArtifact(d.getGroupId(), d.getArtifactId(),
                        asd.getSupportedPlatform(target), d.getType(), d.getVersion());
            })
            .filter(Objects::nonNull)
            .flatMap(a -> {
                Set<Artifact> resolve = resolver.resolve(a);
                if (resolve == null) {
                    return Stream.empty();
                }
                return resolve.stream();
            })
            .distinct()
            .collect(Collectors.toMap(Artifact::getArtifactId, a -> a));
}
 

public static void updateMavenProjectWithWSO2Repository(MavenProject mavenProject){
	Repository repo = new Repository();
	repo.setUrl("http://maven.wso2.org/nexus/content/groups/wso2-public/");
	repo.setId("wso2-maven2-repository-1");

	mavenProject.getModel().addRepository(repo);
	mavenProject.getModel().addPluginRepository(repo);
}
 

private DefaultModelResolver(
    Aether aether,
    Set<Repository> repositories,
    Map<String, ModelSource> ruleNameToModelSource,
    DefaultModelBuilder modelBuilder) {
  this.repositories = repositories;
  this.ruleNameToModelSource = ruleNameToModelSource;
  this.modelBuilder = modelBuilder;
  this.aether = aether;
  this.versionResolver = new VersionResolver(aether);
}
 

@Override
public List<Repository> load(Logger logger) throws LifecycleExecutionException {
    Path settingsFile = getSettingsFile();

    if (Files.exists(settingsFile)) {
        Optional<String> fileExtension = getFileNameExtension(settingsFile.getFileName().toString());
        return fileExtension.flatMap(this::getFileConfigLoader)
                            .orElse(new PropertyFileRepositoryLoader())
                            .load(settingsFile, logger);
    }

    return Collections.emptyList();
}
 

@Override
public ModelSource resolveModel(String groupId, String artifactId, String version)
    throws UnresolvableModelException {
  String ruleName = Rule.name(groupId, artifactId);
  if (ruleNameToModelSource.containsKey(ruleName)) {
    return ruleNameToModelSource.get(ruleName);
  }
  for (Repository repository : repositories) {
    UrlModelSource modelSource =
        getModelSource(repository.getUrl(), groupId, artifactId, version);
    if (modelSource != null) {
      return modelSource;
    }
  }

  List<String> attemptedUrls = repositories.stream().map(Repository::getUrl).collect(toList());
  throw new UnresolvableModelException(
      "Could not find any repositories that knew how to "
          + "resolve "
          + groupId
          + ":"
          + artifactId
          + ":"
          + version
          + " (checked "
          + Joiner.on(", ").join(attemptedUrls)
          + ")",
      groupId,
      artifactId,
      version);
}
 

public void createPOM(File pomLocation, String packagingType) throws Exception {
	MavenInfo mavenInfo = getModel().getMavenInfo();

	String customGroupId =
	                       preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
	                                                    GLOBAL_MAVEN_GROUP_ID, null, null);
	String customVersion =
	                       preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
	                                                    GLOBAL_MAVEN_VERSION, null, null);

	MavenProject mavenProject =
	                            MavenUtils.createMavenProject(customGroupId != null ? customGroupId
	                                                                               : mavenInfo.getGroupId(),
	                                                          mavenInfo.getArtifactId(),
	                                                          customVersion != null ? customVersion
	                                                                               : mavenInfo.getVersion(),
	                                                          packagingType);

	Parent parentProject = getModel().getMavenInfo().getParentProject();
	if (parentProject != null) {
		mavenProject.getModel().setParent(parentProject);
	}
	String disableWSO2Repo = preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
	                                                      DISABLE_WSO2_REPOSITORY, null, null);
	if (disableWSO2Repo == null) {
		MavenUtils.updateMavenRepo(mavenProject);
	}
	Repository globalRepositoryFromPreference = getGlobalRepositoryFromPreference();

	if (globalRepositoryFromPreference != null) {
		mavenProject.getModel().addRepository(globalRepositoryFromPreference);
		mavenProject.getModel().addPluginRepository(globalRepositoryFromPreference);
	}
	MavenUtils.saveMavenProject(mavenProject, pomLocation);
}
 

public void createPOM(File pomLocation) throws Exception {
	MavenInfo mavenInfo = getModel().getMavenInfo();

	String customGroupId = preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
	                                                    GLOBAL_MAVEN_GROUP_ID, null, null);
	String customVersion = preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
	                                                    GLOBAL_MAVEN_VERSION, null, null);

	MavenProject mavenProject = MavenUtils.createMavenProject(customGroupId != null ? customGroupId
	                                                                               : mavenInfo.getGroupId(),
	                                                          mavenInfo.getArtifactId(),
	                                                          customVersion != null ? customVersion
	                                                                               : mavenInfo.getVersion(),
	                                                          mavenInfo.getPackageName());
	Parent parentProject = getModel().getMavenInfo().getParentProject();
	if (parentProject != null) {
		mavenProject.getModel().setParent(parentProject);
	}
	String disableWSO2Repo = preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
	                                                      DISABLE_WSO2_REPOSITORY, null, null);
	if (disableWSO2Repo == null) {
		MavenUtils.updateMavenRepo(mavenProject);
	}
	Repository globalRepositoryFromPreference = getGlobalRepositoryFromPreference();

	if (globalRepositoryFromPreference != null) {
		mavenProject.getModel().addRepository(globalRepositoryFromPreference);
		mavenProject.getModel().addPluginRepository(globalRepositoryFromPreference);
	}

	MavenUtils.saveMavenProject(mavenProject, pomLocation);
}
 

@Override
protected List<Repository> load(Path filePath, Logger logger) throws LifecycleExecutionException {
    try {
        List<Repository> repositoryList = new ArrayList<>();
        Yaml yaml = new Yaml();

        HashMap<String, List<Map<String, Object>>> root = yaml.load(new StringReader(new String(Files.readAllBytes(filePath), StandardCharsets.UTF_8)));
        if (root.containsKey("repositories")) {
            for (Map<String, Object> model : root.get("repositories")) {
                Repository repository = new Repository();

                repository.setId(Objects.toString(model.get("id")));
                repository.setName(Objects.toString(model.getOrDefault("name", repository.getId())));
                repository.setUrl(Objects.toString(model.get("url")));
                repository.setLayout(Objects.toString(model.getOrDefault("layout", "default")));

                if (model.containsKey("releases")) {
                    repository.setReleases(getRepositoryPolicy((Map<String, Object>) model.get("releases")));
                }

                if (model.containsKey("snapshots")) {
                    repository.setReleases(getRepositoryPolicy((Map<String, Object>) model.get("snapshots")));
                }

                logger.info(String.format("Add Repository %s=%s", repository.getId(), repository.getUrl()));
                repositoryList.add(repository);
            }
        }

        return repositoryList;
    } catch (IOException e) {
        throw new LifecycleExecutionException("Failed to read repository configuration file", e);
    }
}
 

private void writeRepository(Repository repository, String tagName, XmlSerializer serializer)
        throws java.io.IOException {
    serializer.startTag(NAMESPACE, tagName);
    flush(serializer);
    StringBuffer b = b(serializer);
    int start = b.length();
    if (repository.getReleases() != null) {
        writeRepositoryPolicy((RepositoryPolicy) repository.getReleases(), "releases", serializer);
    }
    if (repository.getSnapshots() != null) {
        writeRepositoryPolicy((RepositoryPolicy) repository.getSnapshots(), "snapshots", serializer);
    }
    if (repository.getId() != null) {
        writeValue(serializer, "id", repository.getId(), repository);
    }
    if (repository.getName() != null) {
        writeValue(serializer, "name", repository.getName(), repository);
    }
    if (repository.getUrl() != null) {
        writeValue(serializer, "url", repository.getUrl(), repository);
    }
    if ((repository.getLayout() != null) && !repository.getLayout().equals("default")) {
        writeValue(serializer, "layout", repository.getLayout(), repository);
    }
    serializer.endTag(NAMESPACE, tagName).flush();
    logLocation(repository, "", start, b.length());
}
 

protected Repository getGlobalRepositoryFromPreference() {

		String repoURL =
		                 preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
		                                              GLOBAL_REPOSITORY_URL, null, null);
		if (repoURL != null) {
			Repository repo = new Repository();
			repo.setUrl(repoURL);
			repo.setId(preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
			                                        GLOBAL_REPOSITORY_ID, null, null));
			RepositoryPolicy releasePolicy = new RepositoryPolicy();
			String releaseEnabled =
			                        preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
			                                                     RELEASES_ENABLED, null, null);
			releasePolicy.setEnabled(releaseEnabled != null);
			releasePolicy.setUpdatePolicy(preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
			                                                           RELEASES_UPDATE_POLICY, null, null));
			releasePolicy.setChecksumPolicy(preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
			                                                             RELEASES_CHECKSUM_POLICY, null, null));
			repo.setReleases(releasePolicy);

			RepositoryPolicy snapshotPolicy = new RepositoryPolicy();
			String snapshotsEnabled =
			                          preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
			                                                       SNAPSHOTS_ENABLED, null, null);
			snapshotPolicy.setEnabled(snapshotsEnabled != null);
			snapshotPolicy.setUpdatePolicy(preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
			                                                            SNAPSHOTS_UPDATE_POLICY, null, null));
			snapshotPolicy.setChecksumPolicy(preferencesService.getString("org.wso2.developerstudio.eclipse.platform.ui",
			                                                              SNAPSHOTS_CHECKSUM_POLICY, null, null));
			repo.setSnapshots(snapshotPolicy);

			return repo;
		}
		return null;
	}
 

@Override
public void addRepository(Repository repository, boolean replace) throws InvalidRepositoryException {
    RepositorySystem repositorySystem = embedder.lookupComponent(RepositorySystem.class);
    try {
        ArtifactRepository repo = repositorySystem.buildArtifactRepository(repository);
        if(replace) { 
            remoteRepositories.remove(repo);
        }
        remoteRepositories.add(repo);
        remoteRepositories = repositorySystem.getEffectiveRepositories( remoteRepositories );
    } catch (org.apache.maven.artifact.InvalidRepositoryException ex) {
        throw new InvalidRepositoryException(ex.toString(), repository, ex);
    }
}
 

private Repository createRepo(String id, String url, String layout) {
	Repository repo = new Repository();
	repo.setId(id);
	repo.setUrl(url);
	repo.setLayout(layout);
	return repo;
}
 

private void download(File localRepoFile) throws IOException {
    for (Repository repository1 : repositories) {
        String repository1Url = repository1.getUrl();
        if (repository1Url.endsWith("/")) {
            repository1Url = repository1Url.substring(0, repository1Url.length() - 1);
        }
        URL url = new URL(repository1Url
                + localRepoFile.getAbsolutePath().substring(this.localRepository.getAbsolutePath().length()));

        logger.debug("Downloading " + url);

        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url(url)
                .build();

        Response response = client.newCall(request).execute();

        if (response.code() == 200) {
            localRepoFile.getParentFile().mkdirs();
            FileWriter out = new FileWriter(localRepoFile);
            out.write(response.body().string());
            out.flush();
            out.close();
            return;
        }
    }
}
 

@Override
public void addRepository(Repository repository, boolean b) throws InvalidRepositoryException {
    for (Repository existingRepository : repositories) {
        if (existingRepository.getId().equals(repository.getId()) && !b) {
            return;
        }
    }

    repositories.add(repository);
}