Example usage for org.apache.maven.artifact.repository ArtifactRepositoryPolicy ArtifactRepositoryPolicy

List of usage examples for org.apache.maven.artifact.repository ArtifactRepositoryPolicy ArtifactRepositoryPolicy

  1. HOME
  2. Java
  3. org.apache.maven
  4. org.apache.maven.artifact.repository.*
  5. ArtifactRepositoryPolicy
  6. ArtifactRepositoryPolicy

Introduction

In this page you can find the example usage for org.apache.maven.artifact.repository ArtifactRepositoryPolicy ArtifactRepositoryPolicy.

Prototype

public ArtifactRepositoryPolicy()

Source Link

Usage

From source file:com.effectivemaven.centrepoint.maven.repository.CentralRepositoryService.java

License:Apache License

@Inject
private CentralRepositoryService(RepositoryParams params) {
    try {/*www.  j ava  2s. c o m*/
        // jetty:run friendly setting
        Map<? extends Object, ? extends Object> context = Collections
                .singletonMap(PlexusConstants.IGNORE_CONTAINER_CONFIGURATION, Boolean.TRUE);

        // use Plexus to load the Maven components needed to retrieve repository information
        InputStreamReader configurationReader = new InputStreamReader(
                getClass().getResourceAsStream("/custom-plexus.xml"));
        PlexusContainer container = new DefaultPlexusContainer(configurationReader, context);

        this.artifactFactory = (ArtifactFactory) container.lookup(ArtifactFactory.ROLE);

        this.metadataSource = (ArtifactMetadataSource) container.lookup(MavenMetadataSource.ROLE,
                MavenMetadataSource.ROLE_HINT);

        ArtifactRepositoryFactory repositoryFactory = (ArtifactRepositoryFactory) container
                .lookup(ArtifactRepositoryFactory.ROLE);

        String localRepositoryUrl = new File(params.localRepositoryPath).toURL().toExternalForm();
        this.localRepository = repositoryFactory.createDeploymentArtifactRepository("local", localRepositoryUrl,
                new DefaultRepositoryLayout(), false);

        repository = repositoryFactory.createArtifactRepository("central", params.repositoryUrl,
                new DefaultRepositoryLayout(), new ArtifactRepositoryPolicy(), new ArtifactRepositoryPolicy());

        projectBuilder = (MavenProjectBuilder) container.lookup(MavenProjectBuilder.ROLE);
    } catch (Exception e) {
        throw new RuntimeException("Error starting Maven components for repository service", e);
    }
}

From source file:de.fct.companian.analyze.mvn.helper.MvnProjectBuilder.java

License:Apache License

public static MavenProject buildMavenProject(File pomFile) {
    if (logger.isDebugEnabled()) {
        logger.debug("buildMavenProject() start, pomFile=" + pomFile);
    }//from w ww  .  jav  a 2  s  .  c  o  m
    MavenProject mvnProject = null;

    ClassWorld classWorld = new ClassWorld("plexus.core", Thread.currentThread().getContextClassLoader());

    ContainerConfiguration cc = new DefaultContainerConfiguration().setClassWorld(classWorld)
            .setName("embedder");

    DefaultPlexusContainer container;
    org.codehaus.plexus.logging.Logger mvnLogger;
    try {
        mvnLogger = new ConsoleLogger(org.codehaus.plexus.logging.Logger.LEVEL_DEBUG, "Console");
        container = new DefaultPlexusContainer(cc);
        container.setLoggerManager(new MavenLoggerManager(mvnLogger));
        container.getLoggerManager().setThresholds(org.codehaus.plexus.logging.Logger.LEVEL_DEBUG);

        ProjectBuilder builder;
        try {
            builder = container.lookup(ProjectBuilder.class);
            logger.info("buildMavenProject() project builder = " + builder);

            try {

                ArtifactRepositoryFactory repoFactory = new DefaultArtifactRepositoryFactory();

                ArtifactRepository localRepo = repoFactory.createArtifactRepository("mylocal",
                        "file://h:/maven/repository", new DefaultRepositoryLayout(),
                        new ArtifactRepositoryPolicy(), new ArtifactRepositoryPolicy());

                List<ArtifactRepository> remoteRepos = new ArrayList<ArtifactRepository>();
                ArtifactRepository mvnCentral = repoFactory.createArtifactRepository("mvnCentral",
                        "http://repo1.maven.org/maven2/", new DefaultRepositoryLayout(),
                        new ArtifactRepositoryPolicy(), new ArtifactRepositoryPolicy());
                remoteRepos.add(mvnCentral);

                ProjectBuildingRequest buildRequest = new DefaultProjectBuildingRequest();
                buildRequest.setLocalRepository(localRepo);
                buildRequest.setRemoteRepositories(remoteRepos);
                buildRequest.setResolveDependencies(true);
                buildRequest.setOffline(false);

                ProjectBuildingResult buildResult = builder.build(pomFile, buildRequest);
                if (buildResult != null) {
                    logger.info("buildMavenProject() got a build result");

                    mvnProject = buildResult.getProject();
                }
            } catch (ProjectBuildingException e) {
                logger.error("buildMavenProject() error building project", e);
            }

        } catch (ComponentLookupException e) {
            logger.error("buildMavenProject() error looking up ArtifactResolver", e);
        }
    } catch (PlexusContainerException e) {
        logger.error("buildMavenProject() error from Plexus container", e);
    }

    if (logger.isDebugEnabled()) {
        logger.debug("buildMavenProject() finished, mvnProject=" + mvnProject);
    }
    return mvnProject;
}

From source file:hudson.maven.artifact.AbstractArtifactComponentTestCase.java

License:Apache License

protected ArtifactRepository remoteRepository() throws Exception {
    String path = "target/test-classes/repositories/" + component() + "/remote-repository";

    File f = new File(getBasedir(), path);

    ArtifactRepositoryLayout repoLayout = (ArtifactRepositoryLayout) lookup(ArtifactRepositoryLayout.ROLE,
            "default");

    ArtifactRepository repo = new DefaultArtifactRepository("test", "file://" + f.getPath(), repoLayout,
            new ArtifactRepositoryPolicy(), new ArtifactRepositoryPolicy()) {
        {/*from   w  w w. j  a  v  a 2 s  . co  m*/

        }

        @Override
        public boolean isUniqueVersion() {
            return false;
        }
    };

    return repo;
}

From source file:org.appformer.maven.integration.MavenRepositoryConfiguration.java

License:Apache License

private ArtifactRepository toArtifactRepository(RemoteRepository remoteRepository) {
    final String id = remoteRepository.getId();
    final String url = remoteRepository.getUrl();
    final ArtifactRepositoryLayout layout = new DefaultRepositoryLayout();
    ArtifactRepositoryPolicy snapshots = new ArtifactRepositoryPolicy();
    ArtifactRepositoryPolicy releases = new ArtifactRepositoryPolicy();
    if (remoteRepository.getPolicy(true) != null) {
        snapshots = new ArtifactRepositoryPolicy(remoteRepository.getPolicy(true).isEnabled(),
                remoteRepository.getPolicy(true).getUpdatePolicy(),
                remoteRepository.getPolicy(true).getChecksumPolicy());
    }//w  ww.j av  a  2s.c  o  m
    if (remoteRepository.getPolicy(false) != null) {
        releases = new ArtifactRepositoryPolicy(remoteRepository.getPolicy(false).isEnabled(),
                remoteRepository.getPolicy(false).getUpdatePolicy(),
                remoteRepository.getPolicy(false).getChecksumPolicy());
    }
    final ArtifactRepository artifactRepository = new MavenArtifactRepository(id, url, layout, snapshots,
            releases);

    final Server server = settings.getServer(id);
    if (server != null) {
        artifactRepository.setAuthentication(new Authentication(server.getUsername(), server.getPassword()));
    }
    return artifactRepository;
}

From source file:org.codehaus.mojo.graphing.model.factory.GraphModelFactory.java

License:Apache License

private ArtifactRepositoryPolicy getArtifactPolicy(RepositoryPolicy policy) {
    if (policy == null) {
        return null;
    }//ww  w  .j  av a2s  .  c o m

    ArtifactRepositoryPolicy artipolicy = new ArtifactRepositoryPolicy();

    artipolicy.setChecksumPolicy(policy.getChecksumPolicy());
    artipolicy.setEnabled(policy.isEnabled());
    artipolicy.setUpdatePolicy(policy.getUpdatePolicy());

    return artipolicy;
}

From source file:org.commonjava.maven.ext.io.resolver.MavenLocationExpander.java

License:Apache License

private ArtifactRepositoryPolicy convertPolicy(final RepositoryPolicy policy) {
    if (policy == null) {
        return new ArtifactRepositoryPolicy();
    }//from   w w w.java  2 s.c om

    return new ArtifactRepositoryPolicy(policy.isEnabled(), policy.getUpdatePolicy(),
            policy.getChecksumPolicy());
}

From source file:org.fusesource.mop.MOPRepository.java

License:Open Source License

/**
 * Adds some default remote repositories
 * //from  w ww  . ja v a 2s  . c  om
 * @param repositorySystem
 */
protected List<ArtifactRepository> createRemoteRepositories(RepositorySystem repositorySystem) {

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

    String mavenRepositoryDir = System.getProperty("user.home", ".") + "/.m2/repository";
    rc.add(createLocalRepository(repositorySystem, RepositorySystem.DEFAULT_LOCAL_REPO_ID, mavenRepositoryDir,
            true));

    DefaultRepositoryLayout layout = new DefaultRepositoryLayout();
    ArtifactRepositoryPolicy repositoryPolicy = new ArtifactRepositoryPolicy();

    if (online) {
        repositoryPolicy.setUpdatePolicy(updatePolicy);
    } else {
        repositoryPolicy.setUpdatePolicy(ArtifactRepositoryPolicy.UPDATE_POLICY_NEVER);
    }

    for (Map.Entry<String, String> entry : remoteRepositories.entrySet()) {
        String repoUrl = entry.getValue();

        //Let's strip the username password out so that it doesn't get displayed:
        Authentication auth = null;
        try {
            URL url = new URL(entry.getValue().toString());
            String userInfo = url.getUserInfo();
            if (userInfo != null) {
                StringTokenizer tok = new StringTokenizer(userInfo, ":");
                if (tok.countTokens() == 1) {
                    auth = new Authentication(userInfo, null);
                } else if (tok.countTokens() == 2) {
                    auth = new Authentication(tok.nextToken(), tok.nextToken());
                } else if (tok.countTokens() > 2) {
                    auth = new Authentication(tok.nextToken(), userInfo.substring(userInfo.indexOf(":") + 1));
                }

                repoUrl = url.getProtocol() + "://" + repoUrl.substring(repoUrl.indexOf("@") + 1);
            }
        } catch (MalformedURLException e) {
            warn("Invalid Repository url for: " + entry.getKey() + ": " + entry.getValue());
        }

        ArtifactRepository ar = repositorySystem.createArtifactRepository(entry.getKey(), repoUrl, layout,
                repositoryPolicy, repositoryPolicy);
        if (auth != null) {
            ar.setAuthentication(auth);
        }

        rc.add(ar);

    }

    return rc;
}

From source file:org.fusesource.mop.MOPRepository.java

License:Open Source License

private ArtifactRepository createLocalRepository(RepositorySystem repositorySystem, String id, String path,
        boolean asRemote) {
    // This hack needed since the local repo is being accessed as a remote repo.
    final ArtifactRepository localRepository[] = new ArtifactRepository[1];
    DefaultRepositoryLayout layout = null;
    if (asRemote) {
        layout = new DefaultRepositoryLayout() {
            @Override//from   w  w  w. j a  v a  2s  .  c  o m
            @SuppressWarnings("deprecation")
            public String pathOfRemoteRepositoryMetadata(
                    org.apache.maven.artifact.metadata.ArtifactMetadata metadata) {
                return super.pathOfLocalRepositoryMetadata(metadata, localRepository[0]);
            }
        };
    }

    //Always check local repo for updates:
    ArtifactRepositoryPolicy repositoryPolicy = new ArtifactRepositoryPolicy();
    if (online) {
        repositoryPolicy.setUpdatePolicy(localRepoUpdatePolicy);
    } else {
        repositoryPolicy.setUpdatePolicy(ArtifactRepositoryPolicy.UPDATE_POLICY_NEVER);
    }

    repositoryPolicy.setChecksumPolicy(ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE);
    localRepository[0] = repositorySystem.createArtifactRepository(id, "file://" + path, layout,
            repositoryPolicy, repositoryPolicy);
    ArtifactRepository repository = localRepository[0];
    return repository;
}

From source file:org.jboss.ce.mvns2i.MavenUtils.java

License:Open Source License

public String getDeploymentDir(String projectDir) throws Exception {
    ProjectBuilder projectBuilder = create(ProjectBuilder.class);

    File pomFile = new File(projectDir, "pom.xml");

    MavenExecutionRequest mer = new DefaultMavenExecutionRequest();

    File mvnDir;/*from w ww. java2  s .  com*/
    String m2dir = System.getProperty("maven.repo");
    if (m2dir != null) {
        mvnDir = new File(m2dir);
    } else {
        mvnDir = new File(System.getProperty("user.home"), ".m2/repository");
    }
    if (mvnDir.exists() == false) {
        //noinspection ResultOfMethodCallIgnored
        mvnDir.mkdirs();
    }
    log.info(String.format("Using Maven repository: %s", mvnDir));

    final Checker checker = new Checker();
    ProjectBuildingRequest request = mer.getProjectBuildingRequest();
    request.setActiveProfileIds(Collections.singletonList(checker.getDefaultProfile()));

    MavenArtifactRepository artifactRepository = new MavenArtifactRepository("local", mvnDir.toURI().toString(),
            create(ArtifactRepositoryLayout.class), new ArtifactRepositoryPolicy(),
            new ArtifactRepositoryPolicy());
    request.setLocalRepository(artifactRepository);

    DefaultRepositorySystemSession session = MavenRepositorySystemUtils.newSession();
    session.setOffline(!Boolean.getBoolean("online")); // use offline by default

    LocalRepository localRepository = new LocalRepository(mvnDir);
    LocalRepositoryManager localRepositoryManager = create(LocalRepositoryManagerFactory.class)
            .newInstance(session, localRepository);
    session.setLocalRepositoryManager(localRepositoryManager);
    request.setRepositorySession(session);

    MavenRepositorySystem mrs = create(MavenRepositorySystem.class);
    ArtifactRepository remoteRepository = mrs.createDefaultRemoteRepository(mer);
    List<ArtifactRepository> repositories = Arrays.asList(artifactRepository, remoteRepository);
    request.setRemoteRepositories(repositories);

    MavenProject project = projectBuilder.build(pomFile, request).getProject();
    recurse(projectBuilder, request, checker, new File(projectDir), "", project);

    return checker.result();
}

From source file:org.phpmaven.test.AbstractTestCase.java

License:Apache License

protected MavenData createProjectBuildingRequest() throws Exception {
    final File localReposFile = this.getLocalReposDir();

    final SimpleLocalRepositoryManager localRepositoryManager = new SimpleLocalRepositoryManager(
            localReposFile);/* w w  w . j  a va 2 s  . com*/

    final DefaultRepositorySystemSession repositorySession = new DefaultRepositorySystemSession();
    for (final Map.Entry<Object, Object> entry : System.getProperties().entrySet()) {
        repositorySession.getSystemProperties().put(entry.getKey().toString(), entry.getValue().toString());
    }
    repositorySession.getSystemProperties().put("java.version", System.getProperty("java.version"));
    repositorySession.setDependencyGraphTransformer(
            new ChainedDependencyGraphTransformer(new ConflictMarker(), new JavaEffectiveScopeCalculator(),
                    new NearestVersionConflictResolver(), new JavaDependencyContextRefiner()));
    final MavenExecutionRequest request = new DefaultMavenExecutionRequest();
    final MavenExecutionRequestPopulator populator = lookup(MavenExecutionRequestPopulator.class);
    populator.populateDefaults(request);

    final SettingsBuildingRequest settingsRequest = new DefaultSettingsBuildingRequest();
    settingsRequest.setGlobalSettingsFile(MavenCli.DEFAULT_GLOBAL_SETTINGS_FILE);
    settingsRequest.setUserSettingsFile(MavenCli.DEFAULT_USER_SETTINGS_FILE);
    settingsRequest.setSystemProperties(request.getSystemProperties());
    settingsRequest.setUserProperties(request.getUserProperties());
    final SettingsBuilder settingsBuilder = lookup(SettingsBuilder.class);
    final SettingsBuildingResult settingsResult = settingsBuilder.build(settingsRequest);
    final MavenExecutionRequestPopulator executionRequestPopulator = lookup(
            MavenExecutionRequestPopulator.class);
    executionRequestPopulator.populateFromSettings(request, settingsResult.getEffectiveSettings());

    final ArtifactRepositoryLayout layout = lookup(ArtifactRepositoryLayout.class);
    final ArtifactRepositoryPolicy policy = new ArtifactRepositoryPolicy();
    final MavenArtifactRepository repos = new MavenArtifactRepository("local",
            localReposFile.toURI().toURL().toString(), layout, policy, policy);

    request.setLocalRepository(repos);
    request.setSystemProperties(new Properties(System.getProperties()));
    request.getSystemProperties().put("java.version", System.getProperty("java.version"));
    repositorySession.setLocalRepositoryManager(localRepositoryManager);

    final ProjectBuildingRequest buildingRequest = new DefaultProjectBuildingRequest();
    buildingRequest.setLocalRepository(request.getLocalRepository());
    buildingRequest.setRepositorySession(repositorySession);
    buildingRequest.setSystemProperties(request.getSystemProperties());
    buildingRequest.getRemoteRepositories().addAll(request.getRemoteRepositories());
    buildingRequest.setProfiles(request.getProfiles());
    buildingRequest.setActiveProfileIds(request.getActiveProfiles());
    buildingRequest.setProcessPlugins(false);
    buildingRequest.setResolveDependencies(false);

    final MavenData data = new MavenData();
    data.executionRequest = request;
    data.projectBuildingRequest = buildingRequest;

    return data;
}