Java InvalidRepositoryException类代码示例

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
private ArtifactRepository createLocalRepository() {
  try {
    return getComponent(RepositorySystem.class).createLocalRepository(new File(myMavenSettings.getLocalRepository()));
  }
  catch (InvalidRepositoryException e) {
    throw new RuntimeException(e);
    // Legacy code.
  }
  //ArtifactRepositoryLayout layout = getComponent(ArtifactRepositoryLayout.class, "default");
  //ArtifactRepositoryFactory factory = getComponent(ArtifactRepositoryFactory.class);
  //
  //String url = myMavenSettings.getLocalRepository();
  //if (!url.startsWith("file:")) url = "file://" + url;
  //
  //ArtifactRepository localRepository = factory.createArtifactRepository("local", url, layout, null, null);
  //
  //boolean snapshotPolicySet = myMavenSettings.isOffline();
  //if (!snapshotPolicySet && snapshotUpdatePolicy == MavenServerSettings.UpdatePolicy.ALWAYS_UPDATE) {
  //  factory.setGlobalUpdatePolicy(ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS);
  //}
  //factory.setGlobalChecksumPolicy(ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN);
  //
  //return localRepository;
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
public static ArtifactRepository buildArtifactRepository( Repository repo,
                                                          ArtifactRepositoryFactory artifactRepositoryFactory,
                                                          PlexusContainer c )
    throws InvalidRepositoryException
{
    RepositorySystem repositorySystem = rs( c );
    RepositorySystemSession session = rss( c );

    ArtifactRepository repository = repositorySystem.buildArtifactRepository( repo );

    if ( session != null )
    {
        repositorySystem.injectMirror( session, Arrays.asList( repository ) );
        repositorySystem.injectProxy( session, Arrays.asList( repository ) );
        repositorySystem.injectAuthentication( session, Arrays.asList( repository ) );
    }

    return repository;
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
private void injectDefaultRepositories( MavenExecutionRequest request )
    throws MavenExecutionRequestPopulationException
{
    Set<String> definedRepositories = getRepoIds( request.getRemoteRepositories() );

    if ( !definedRepositories.contains( RepositorySystem.DEFAULT_REMOTE_REPO_ID ) )
    {
        try
        {
            request.addRemoteRepository( repositorySystem.createDefaultRemoteRepository() );
        }
        catch ( InvalidRepositoryException e )
        {
            throw new MavenExecutionRequestPopulationException( "Cannot create default remote repository.", e );
        }
    }
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
private void injectDefaultPluginRepositories( MavenExecutionRequest request )
    throws MavenExecutionRequestPopulationException
{
    Set<String> definedRepositories = getRepoIds( request.getPluginArtifactRepositories() );

    if ( !definedRepositories.contains( RepositorySystem.DEFAULT_REMOTE_REPO_ID ) )
    {
        try
        {
            request.addPluginArtifactRepository( repositorySystem.createDefaultRemoteRepository() );
        }
        catch ( InvalidRepositoryException e )
        {
            throw new MavenExecutionRequestPopulationException( "Cannot create default remote repository.", e );
        }
    }
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
public ArtifactRepository createLocalRepository( MavenExecutionRequest request )
    throws MavenExecutionRequestPopulationException
{
    String localRepositoryPath = null;

    if ( request.getLocalRepositoryPath() != null )
    {
        localRepositoryPath = request.getLocalRepositoryPath().getAbsolutePath();
    }

    if ( StringUtils.isEmpty( localRepositoryPath ) )
    {
        localRepositoryPath = RepositorySystem.defaultUserLocalRepository.getAbsolutePath();
    }

    try
    {
        return repositorySystem.createLocalRepository( new File( localRepositoryPath ) );
    }
    catch ( InvalidRepositoryException e )
    {
        throw new MavenExecutionRequestPopulationException( "Cannot create local repository.", e );
    }
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
protected List<ArtifactRepository> getRemoteRepositories()
    throws InvalidRepositoryException
{
    File repoDir = new File( getBasedir(), "src/test/remote-repo" ).getAbsoluteFile();

    RepositoryPolicy policy = new RepositoryPolicy();
    policy.setEnabled( true );
    policy.setChecksumPolicy( "ignore" );
    policy.setUpdatePolicy( "always" );

    Repository repository = new Repository();
    repository.setId( RepositorySystem.DEFAULT_REMOTE_REPO_ID );
    repository.setUrl( "file://" + repoDir.toURI().getPath() );
    repository.setReleases( policy );
    repository.setSnapshots( policy );

    return Arrays.asList( repositorySystem.buildArtifactRepository( repository ) );
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
public ArtifactRepository getLocalRepository() {
    try {
        String localRepositoryPath = getSettings().getLocalRepository();
        if (localRepositoryPath != null) {
            return repositorySystem.createLocalRepository(FileUtil.normalizeFile(new File(localRepositoryPath)));
        }
        return repositorySystem.createDefaultLocalRepository();
    } catch (InvalidRepositoryException ex) {
        // can't happen
        throw new IllegalStateException(ex);
    }
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
private ArtifactRepository createLocalRepository() {
  try {
    final ArtifactRepository localRepository =
      getComponent(RepositorySystem.class).createLocalRepository(new File(myMavenSettings.getLocalRepository()));
    final String customRepoId = System.getProperty("maven3.localRepository.id", "localIntelliJ");
    if (customRepoId != null) {
      // see details at https://youtrack.jetbrains.com/issue/IDEA-121292
      localRepository.setId(customRepoId);
    }
    return localRepository;
  }
  catch (InvalidRepositoryException e) {
    throw new RuntimeException(e);
    // Legacy code.
  }
  //ArtifactRepositoryLayout layout = getComponent(ArtifactRepositoryLayout.class, "default");
  //ArtifactRepositoryFactory factory = getComponent(ArtifactRepositoryFactory.class);
  //
  //String url = myMavenSettings.getLocalRepository();
  //if (!url.startsWith("file:")) url = "file://" + url;
  //
  //ArtifactRepository localRepository = factory.createArtifactRepository("local", url, layout, null, null);
  //
  //boolean snapshotPolicySet = myMavenSettings.isOffline();
  //if (!snapshotPolicySet && snapshotUpdatePolicy == MavenServerSettings.UpdatePolicy.ALWAYS_UPDATE) {
  //  factory.setGlobalUpdatePolicy(ArtifactRepositoryPolicy.UPDATE_POLICY_ALWAYS);
  //}
  //factory.setGlobalChecksumPolicy(ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN);
  //
  //return localRepository;
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
@NotNull
protected List<ArtifactRepository> convertRepositories(List<MavenRemoteRepository> repositories) throws RemoteException {
  List<ArtifactRepository> result = new ArrayList<ArtifactRepository>();
  for (MavenRemoteRepository each : repositories) {
    try {
      ArtifactRepositoryFactory factory = getComponent(ArtifactRepositoryFactory.class);
      result.add(ProjectUtils.buildArtifactRepository(MavenModelConverter.toNativeRepository(each), factory, myContainer));
    }
    catch (InvalidRepositoryException e) {
      Maven3ServerGlobals.getLogger().warn(e);
    }
  }
  return result;
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
private List<ArtifactRepository> convertRepositories(List<MavenRemoteRepository> repositories) throws RemoteException {
  List<ArtifactRepository> result = new ArrayList<ArtifactRepository>();
  for (MavenRemoteRepository each : repositories) {
    try {
      ArtifactRepositoryFactory factory = getComponent(ArtifactRepositoryFactory.class);
      result.add(ProjectUtils.buildArtifactRepository(Maven2ModelConverter.toNativeRepository(each), factory, getContainer()));
    }
    catch (InvalidRepositoryException e) {
      Maven2ServerGlobals.getLogger().warn(e);
    }
  }
  return result;
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
private static List<ArtifactRepository> repositoriesLegacy(LegacyRepositorySystem legacy, Settings settings)
        throws InvalidRepositoryException {
    boolean central;
    List<ArtifactRepository> result;
    List<String> actives;
    ArtifactRepository artifactRepository;

    central = false;
    result = new ArrayList<>();
    actives = settings.getActiveProfiles();
    for (Profile profile : settings.getProfiles()) {
        if (actives.contains(profile.getId()) || (profile.getActivation() != null && profile.getActivation().isActiveByDefault())) {
            for (org.apache.maven.model.Repository repository : SettingsUtils.convertFromSettingsProfile(profile).getRepositories()) {
                artifactRepository = legacy.buildArtifactRepository(repository);
                if ("central".equals(artifactRepository.getId())) {
                    central = true;
                }
                result.add(artifactRepository);
            }
        }
    }
    if (!central) {
        /* Maven defines the default central repository in its master parent - and not in the default settings, which I'd prefer.
           As a consequent, central is not always defined when loading the settings.
           I first added central to repositories only, because legacy repositories are used to load poms which ultimatly load the
           master parent with it's repository definition. However, the parent might have to be loaded from central, so repositories
           also need a central definition. */
        result.add(legacy.createDefaultRemoteRepository());
    }
    return result;
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
private List<ArtifactRepository> convertRepositories(List<MavenRemoteRepository> repositories) throws RemoteException {
  List<ArtifactRepository> result = new ArrayList<ArtifactRepository>();
  for (MavenRemoteRepository each : repositories) {
    try {
      ArtifactRepositoryFactory factory = getComponent(ArtifactRepositoryFactory.class);
      result.add(ProjectUtils.buildArtifactRepository(MavenModelConverter.toNativeRepository(each), factory, myContainer));
    }
    catch (InvalidRepositoryException e) {
      Maven3ServerGlobals.getLogger().warn(e);
    }
  }
  return result;
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
private ArtifactRepository getReleaseRepo() {
	DistributionManagement distributionManagement = project.getDistributionManagement();
       if ( distributionManagement != null && distributionManagement.getRepository() != null ) {        	
       	try {
       		ArtifactRepository repo = repositorySystem.buildArtifactRepository(distributionManagement.getRepository());

               repositorySystem.injectProxy( projectBuilderConfiguration.getRepositorySession(), Arrays.asList( repo ) );
               repositorySystem.injectAuthentication( projectBuilderConfiguration.getRepositorySession(),
                                                      Arrays.asList( repo ) );
               return repo;
       	} catch (InvalidRepositoryException e) {}
       }
       return null;
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
public static List<ArtifactRepository> buildArtifactRepositories( List<Repository> repositories,
                                                                  ArtifactRepositoryFactory artifactRepositoryFactory,
                                                                  PlexusContainer c )
    throws InvalidRepositoryException
{

    List<ArtifactRepository> remoteRepositories = new ArrayList<ArtifactRepository>();

    for ( Repository r : repositories )
    {
        remoteRepositories.add( buildArtifactRepository( r, artifactRepositoryFactory, c ) );
    }

    return remoteRepositories;
}
 

import org.apache.maven.artifact.InvalidRepositoryException; //导入依赖的package包/类
public static ArtifactRepository buildDeploymentArtifactRepository( DeploymentRepository repo,
                                                                    ArtifactRepositoryFactory artifactRepositoryFactory,
                                                                    PlexusContainer c )
    throws InvalidRepositoryException
{
    return buildArtifactRepository( repo, artifactRepositoryFactory, c );
}