Example usage for org.apache.maven.execution MavenSession isOffline

List of usage examples for org.apache.maven.execution MavenSession isOffline

Introduction

In this page you can find the example usage for org.apache.maven.execution MavenSession isOffline.

Prototype

public boolean isOffline() 

Source Link

Usage

From source file:org.debian.dependency.DefaultDependencyCollection.java

License:Apache License

private Artifact resolveArtifact(final Artifact toResolve, final MavenSession session)
        throws DependencyResolutionException {
    // otherwise resolve through the normal means
    ArtifactResolutionRequest request = new ArtifactResolutionRequest()
            .setLocalRepository(session.getLocalRepository())
            .setRemoteRepositories(session.getRequest().getRemoteRepositories())
            .setMirrors(session.getSettings().getMirrors()).setServers(session.getRequest().getServers())
            .setProxies(session.getRequest().getProxies()).setOffline(session.isOffline())
            .setForceUpdate(session.getRequest().isUpdateSnapshots()).setResolveRoot(true)
            .setArtifact(toResolve);/*  w ww . j a  va  2s.  c  om*/

    ArtifactResolutionResult result = repositorySystem.resolve(request);
    if (!result.isSuccess()) {
        if (result.getExceptions() != null) {
            for (Exception exception : result.getExceptions()) {
                getLogger().error("Error resolving artifact " + toResolve, exception);
            }
        }
        throw new DependencyResolutionException("Unable to resolve artifact " + toResolve);
    }

    return result.getArtifacts().iterator().next();
}

From source file:org.eclipse.che.maven.CheArtifactResolver.java

License:Apache License

private void injectSession1(RepositoryRequest request, MavenSession session) {
    if (session != null) {
        request.setOffline(session.isOffline());
        request.setForceUpdate(session.getRequest().isUpdateSnapshots());
    }/* ww w .j  av a 2 s .co  m*/
}

From source file:org.eclipse.tycho.dev.DevWorkspaceResolver.java

License:Open Source License

public DevBundleInfo getBundleInfo(MavenSession session, String groupId, String artifacyId, String version,
        List<ArtifactRepository> repositories) {

    Artifact pomArtifact = repositorySystem.createArtifact(groupId, artifacyId, version, "pom");

    ArtifactResolutionRequest request = new ArtifactResolutionRequest();
    request.setArtifact(pomArtifact);//from  w  w  w .  j a va2 s  .  c o  m
    request.setResolveRoot(true).setResolveTransitively(false);
    request.setLocalRepository(session.getLocalRepository());
    request.setRemoteRepositories(repositories);
    request.setCache(session.getRepositoryCache());
    request.setOffline(session.isOffline());
    request.setForceUpdate(session.getRequest().isUpdateSnapshots());

    ArtifactResolutionResult result = repositorySystem.resolve(request);

    if (result.isSuccess()) {
        return getBundleInfo(pomArtifact.getFile().getParentFile());
    }

    return null;
}

From source file:org.eclipse.tycho.extras.docbundle.DocletArtifactsResolver.java

License:Open Source License

/**
 * Resolves the dependencies and returns a list of paths to the dependency jar files.
 * /*from  w  ww.ja  va  2  s.  c  om*/
 * @param dependencies
 *            the Dependencies to be resolved
 * @return the paths to the jar files
 * @throws MojoExecutionException
 *             if one of the specified depenencies could not be resolved
 */
public Set<String> resolveArtifacts(List<Dependency> dependencies) throws MojoExecutionException {
    Set<String> files = new LinkedHashSet<String>();

    if (dependencies == null || dependencies.isEmpty()) {
        return files;
    }

    MavenSession session = legacySupport.getSession();
    MavenProject project = session.getCurrentProject();

    for (Dependency dependency : dependencies) {
        Artifact artifact = repositorySystem.createDependencyArtifact(dependency);
        ArtifactResolutionRequest request = new ArtifactResolutionRequest();
        request.setArtifact(artifact);
        request.setResolveRoot(true).setResolveTransitively(true);
        request.setLocalRepository(session.getLocalRepository());
        request.setRemoteRepositories(project.getPluginArtifactRepositories());
        request.setOffline(session.isOffline());
        request.setForceUpdate(session.getRequest().isUpdateSnapshots());
        ArtifactResolutionResult result = repositorySystem.resolve(request);
        try {
            resolutionErrorHandler.throwErrors(request, result);
        } catch (ArtifactResolutionException e) {
            throw new MojoExecutionException(
                    "Failed to resolve doclet artifact " + dependency.getManagementKey(), e);
        }
        for (Artifact resolvedArtifact : result.getArtifacts()) {
            files.add(resolvedArtifact.getFile().getAbsolutePath());
        }
    }

    return files;
}

From source file:org.eclipse.tycho.osgi.configuration.MavenContextConfigurator.java

License:Open Source License

@Override
public void afterFrameworkStarted(EmbeddedEquinox framework) {
    MavenSession session = context.getSession();
    MavenContextImpl mavenContext = new MavenContextImpl();
    mavenContext.setLocalRepositoryRoot(new File(session.getLocalRepository().getBasedir()));
    mavenContext.setOffline(session.isOffline());
    boolean extendedDebug = session.getUserProperties().getProperty("tycho.debug.resolver") != null;
    mavenContext.setLogger(new MavenLoggerAdapter(logger, extendedDebug));
    framework.registerService(MavenContext.class, mavenContext);
}

From source file:org.eclipse.tycho.osgi.runtime.TychoOsgiRuntimeLocator.java

License:Open Source License

public Artifact resolveDependency(MavenSession session, Dependency dependency) throws MavenExecutionException {
    Artifact artifact = repositorySystem.createArtifact(dependency.getGroupId(), dependency.getArtifactId(),
            dependency.getVersion(), dependency.getType());

    ArtifactResolutionRequest request = new ArtifactResolutionRequest();
    request.setArtifact(artifact);//from w w  w  .  j  a  v a  2  s  . c  om
    request.setResolveRoot(true).setResolveTransitively(false);
    request.setLocalRepository(session.getLocalRepository());
    request.setRemoteRepositories(getPluginRepositories(session));
    request.setCache(session.getRepositoryCache());
    request.setOffline(session.isOffline());
    request.setProxies(session.getSettings().getProxies());
    request.setForceUpdate(session.getRequest().isUpdateSnapshots());

    ArtifactResolutionResult result = repositorySystem.resolve(request);

    try {
        resolutionErrorHandler.throwErrors(request, result);
    } catch (ArtifactResolutionException e) {
        throw new MavenExecutionException("Could not resolve artifact for Tycho's OSGi runtime", e);
    }

    return artifact;
}

From source file:org.eclipse.tycho.osgi.runtime.TychoP2RuntimeLocator.java

License:Open Source License

private File resolveArtifact(MavenSession session, Artifact artifact) throws MavenExecutionException {
    List<ArtifactRepository> repositories = new ArrayList<ArtifactRepository>();
    for (MavenProject project : session.getProjects()) {
        repositories.addAll(project.getPluginArtifactRepositories());
    }/*from   ww  w .j av  a 2 s .  c  o m*/
    repositories = repositorySystem.getEffectiveRepositories(repositories);

    ArtifactResolutionRequest request = new ArtifactResolutionRequest();
    request.setArtifact(artifact);
    request.setResolveRoot(true).setResolveTransitively(false);
    request.setLocalRepository(session.getLocalRepository());
    request.setRemoteRepositories(repositories);
    request.setCache(session.getRepositoryCache());
    request.setOffline(session.isOffline());
    request.setForceUpdate(session.getRequest().isUpdateSnapshots());

    ArtifactResolutionResult result = repositorySystem.resolve(request);

    try {
        resolutionErrorHandler.throwErrors(request, result);
    } catch (ArtifactResolutionException e) {
        throw new MavenExecutionException("Could not resolve tycho-p2-runtime", e);
    }

    return artifact.getFile();
}

From source file:org.eclipse.tycho.p2.facade.P2TargetPlatformResolver.java

License:Open Source License

protected TargetPlatform doResolvePlatform(final MavenSession session, final MavenProject project,
        List<ReactorProject> reactorProjects, List<Dependency> dependencies, P2Resolver resolver) {
    TargetPlatformConfiguration configuration = (TargetPlatformConfiguration) project
            .getContextValue(TychoConstants.CTX_TARGET_PLATFORM_CONFIGURATION);

    resolver.setRepositoryCache(repositoryCache);

    resolver.setOffline(session.isOffline());

    resolver.setLogger(new P2Logger() {
        public void debug(String message) {
            if (message != null && message.length() > 0) {
                getLogger().info(message); // TODO
            }/* w  ww.  j ava  2s  .co m*/
        }

        public void info(String message) {
            if (message != null && message.length() > 0) {
                getLogger().info(message);
            }
        }

        public boolean isDebugEnabled() {
            return getLogger().isDebugEnabled() && DebugUtils.isDebugEnabled(session, project);
        }
    });

    Map<File, ReactorProject> projects = new HashMap<File, ReactorProject>();

    resolver.setLocalRepositoryLocation(new File(session.getLocalRepository().getBasedir()));

    resolver.setEnvironments(getEnvironments(configuration));

    for (ReactorProject otherProject : reactorProjects) {
        if (getLogger().isDebugEnabled()) {
            getLogger().debug("P2resolver.addMavenProject " + otherProject.getId());
        }
        projects.put(otherProject.getBasedir(), otherProject);
        resolver.addReactorArtifact(new ReactorArtifactFacade(otherProject, null));

        Map<String, Set<Object>> dependencyMetadata = otherProject.getDependencyMetadata();
        if (dependencyMetadata != null) {
            for (String classifier : dependencyMetadata.keySet()) {
                resolver.addReactorArtifact(new ReactorArtifactFacade(otherProject, classifier));
            }
        }
    }

    if (dependencies != null) {
        for (Dependency dependency : dependencies) {
            resolver.addDependency(dependency.getType(), dependency.getArtifactId(), dependency.getVersion());
        }
    }

    if (TargetPlatformConfiguration.POM_DEPENDENCIES_CONSIDER.equals(configuration.getPomDependencies())) {
        Set<String> projectIds = new HashSet<String>();
        for (ReactorProject p : reactorProjects) {
            String key = ArtifactUtils.key(p.getGroupId(), p.getArtifactId(), p.getVersion());
            projectIds.add(key);
        }

        ArrayList<String> scopes = new ArrayList<String>();
        scopes.add(Artifact.SCOPE_COMPILE);
        Collection<Artifact> artifacts;
        try {
            artifacts = projectDependenciesResolver.resolve(project, scopes, session);
        } catch (MultipleArtifactsNotFoundException e) {
            Collection<Artifact> missing = new HashSet<Artifact>(e.getMissingArtifacts());

            for (Iterator<Artifact> it = missing.iterator(); it.hasNext();) {
                Artifact a = it.next();
                String key = ArtifactUtils.key(a.getGroupId(), a.getArtifactId(), a.getBaseVersion());
                if (projectIds.contains(key)) {
                    it.remove();
                }
            }

            if (!missing.isEmpty()) {
                throw new RuntimeException("Could not resolve project dependencies", e);
            }

            artifacts = e.getResolvedArtifacts();
            artifacts.removeAll(e.getMissingArtifacts());
        } catch (AbstractArtifactResolutionException e) {
            throw new RuntimeException("Could not resolve project dependencies", e);
        }
        List<Artifact> externalArtifacts = new ArrayList<Artifact>(artifacts.size());
        for (Artifact artifact : artifacts) {
            String key = ArtifactUtils.key(artifact.getGroupId(), artifact.getArtifactId(),
                    artifact.getBaseVersion());
            if (projectIds.contains(key)) {
                // resolved to an older snapshot from the repo, we only want the current project in the reactor
                continue;
            }
            externalArtifacts.add(artifact);
        }
        addToP2ViewOfLocalRepository(session, externalArtifacts, project);
        for (Artifact artifact : externalArtifacts) {
            /*
             * TODO This call generates p2 metadata for the POM dependencies. If the artifact
             * has an attached p2metadata.xml, we should reuse that metadata.
             */
            /*
             * TODO The generated metadata is "depencency only" metadata. (Just by coincidence
             * this is currently full metadata.) Since this POM depencency metadata may be
             * copied into an eclipse-repository or p2-enabled RCP installation, it shall be
             * documented that the generated metadata must be full metadata.
             */
            if (getLogger().isDebugEnabled()) {
                getLogger().debug("P2resolver.addMavenArtifact " + artifact.toString());
            }
            resolver.addMavenArtifact(new ArtifactFacade(artifact));
        }
    }

    for (ArtifactRepository repository : project.getRemoteArtifactRepositories()) {
        try {
            URI uri = new URL(repository.getUrl()).toURI();

            if (repository.getLayout() instanceof P2ArtifactRepositoryLayout) {
                if (session.isOffline()) {
                    getLogger().debug("Offline mode, using local cache only for repository "
                            + repository.getId() + " (" + repository.getUrl() + ")");
                }

                try {
                    Authentication auth = repository.getAuthentication();
                    if (auth != null) {
                        resolver.setCredentials(uri, auth.getUsername(), auth.getPassword());
                    }

                    resolver.addP2Repository(uri);

                    getLogger().debug(
                            "Added p2 repository " + repository.getId() + " (" + repository.getUrl() + ")");
                } catch (Exception e) {
                    String msg = "Failed to access p2 repository " + repository.getId() + " ("
                            + repository.getUrl() + "), will try to use local cache. Reason: " + e.getMessage();
                    if (getLogger().isDebugEnabled()) {
                        getLogger().warn(msg, e);
                    } else {
                        getLogger().warn(msg);
                    }
                }
            } else {
                if (!configuration.isIgnoreTychoRepositories() && !session.isOffline()) {
                    try {
                        MavenRepositoryReader reader = plexus.lookup(MavenRepositoryReader.class);
                        reader.setArtifactRepository(repository);
                        reader.setLocalRepository(session.getLocalRepository());

                        String repositoryKey = getRepositoryKey(repository);
                        TychoRepositoryIndex index = repositoryCache.getRepositoryIndex(repositoryKey);
                        if (index == null) {
                            index = new DefaultTychoRepositoryIndex(reader);

                            repositoryCache.putRepositoryIndex(repositoryKey, index);
                        }

                        resolver.addMavenRepository(uri, index, reader);
                        getLogger().debug("Added Maven repository " + repository.getId() + " ("
                                + repository.getUrl() + ")");
                    } catch (FileNotFoundException e) {
                        // it happens
                    } catch (Exception e) {
                        getLogger().debug("Unable to initialize remote Tycho repository", e);
                    }
                } else {
                    String msg = "Ignoring Maven repository " + repository.getId() + " (" + repository.getUrl()
                            + ")";
                    if (session.isOffline()) {
                        msg += " while in offline mode";
                    }
                    getLogger().debug(msg);
                }
            }
        } catch (MalformedURLException e) {
            getLogger().warn("Could not parse repository URL", e);
        } catch (URISyntaxException e) {
            getLogger().warn("Could not parse repository URL", e);
        }
    }

    Target target = configuration.getTarget();

    if (target != null) {
        Set<URI> uris = new HashSet<URI>();

        for (Target.Location location : target.getLocations()) {
            String type = location.getType();
            if (!"InstallableUnit".equalsIgnoreCase(type)) {
                getLogger().warn("Target location type: " + type + " is not supported");
                continue;
            }
            for (Target.Repository repository : location.getRepositories()) {

                try {
                    URI uri = new URI(getMirror(repository, session.getRequest().getMirrors()));
                    if (uris.add(uri)) {
                        if (session.isOffline()) {
                            getLogger().debug("Ignored repository " + uri + " while in offline mode");
                        } else {
                            String id = repository.getId();
                            if (id != null) {
                                Server server = session.getSettings().getServer(id);

                                if (server != null) {
                                    resolver.setCredentials(uri, server.getUsername(), server.getPassword());
                                } else {
                                    getLogger().info("Unknown server id=" + id + " for repository location="
                                            + repository.getLocation());
                                }
                            }

                            try {
                                resolver.addP2Repository(uri);
                            } catch (Exception e) {
                                String msg = "Failed to access p2 repository " + uri
                                        + ", will try to use local cache. Reason: " + e.getMessage();
                                if (getLogger().isDebugEnabled()) {
                                    getLogger().warn(msg, e);
                                } else {
                                    getLogger().warn(msg);
                                }
                            }
                        }
                    }
                } catch (URISyntaxException e) {
                    getLogger().debug("Could not parse repository URL", e);
                }
            }

            for (Target.Unit unit : location.getUnits()) {
                String versionRange;
                if ("0.0.0".equals(unit.getVersion())) {
                    versionRange = unit.getVersion();
                } else {
                    // perfect version match
                    versionRange = "[" + unit.getVersion() + "," + unit.getVersion() + "]";
                }
                resolver.addDependency(P2Resolver.TYPE_INSTALLABLE_UNIT, unit.getId(), versionRange);
            }
        }
    }

    if (!isAllowConflictingDependencies(project, configuration)) {
        List<P2ResolutionResult> results = resolver.resolveProject(project.getBasedir());

        MultiEnvironmentTargetPlatform multiPlatform = new MultiEnvironmentTargetPlatform();

        // FIXME this is just wrong
        for (int i = 0; i < configuration.getEnvironments().size(); i++) {
            TargetEnvironment environment = configuration.getEnvironments().get(i);
            P2ResolutionResult result = results.get(i);

            DefaultTargetPlatform platform = newDefaultTargetPlatform(session, projects, result);

            // addProjects( session, platform );

            multiPlatform.addPlatform(environment, platform);
        }

        return multiPlatform;
    } else {
        P2ResolutionResult result = resolver.collectProjectDependencies(project.getBasedir());

        return newDefaultTargetPlatform(session, projects, result);
    }
}

From source file:org.eclipse.tycho.p2.resolver.P2TargetPlatformResolver.java

License:Open Source License

private void addEntireP2RepositoryToTargetPlatform(ArtifactRepository repository,
        TargetPlatformBuilder resolutionContext, MavenSession session) {
    try {//from  w  w w. j a va2s.co m
        URI uri = new URL(repository.getUrl()).toURI();

        if (repository.getLayout() instanceof P2ArtifactRepositoryLayout) {
            if (session.isOffline()) {
                getLogger().debug("Offline mode, using local cache only for repository " + repository.getId()
                        + " (" + repository.getUrl() + ")");
            }

            try {
                Authentication auth = repository.getAuthentication();
                if (auth != null) {
                    resolutionContext.setCredentials(uri, auth.getUsername(), auth.getPassword());
                }

                resolutionContext.addP2Repository(uri);

                getLogger()
                        .debug("Added p2 repository " + repository.getId() + " (" + repository.getUrl() + ")");
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    } catch (MalformedURLException e) {
        getLogger().warn("Could not parse repository URL", e);
    } catch (URISyntaxException e) {
        getLogger().warn("Could not parse repository URL", e);
    }
}

From source file:org.eclipse.tycho.p2.resolver.P2TargetPlatformResolver.java

License:Open Source License

private void addTargetFileContentToTargetPlatform(TargetPlatformConfiguration configuration,
        TargetPlatformBuilder resolutionContext, MavenSession session) {
    final TargetDefinitionFile target;
    try {//from  ww w.jav  a2  s.c  o  m
        target = TargetDefinitionFile.read(configuration.getTarget());
    } catch (TargetDefinitionSyntaxException e) {
        throw new RuntimeException(
                "Invalid syntax in target definition " + configuration.getTarget() + ": " + e.getMessage(), e);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }

    Set<URI> uris = new HashSet<URI>();

    for (Location location : target.getLocations()) {
        if (!(location instanceof InstallableUnitLocation)) {
            continue;
        }
        for (TargetDefinition.Repository repository : ((InstallableUnitLocation) location).getRepositories()) {

            try {
                URI uri = getMirror(repository, session.getRequest().getMirrors());
                if (uris.add(uri)) {
                    if (!session.isOffline()) {
                        String id = repository.getId();
                        if (id != null) {
                            Server server = session.getSettings().getServer(id);

                            if (server != null) {
                                // TODO don't do this via magic side-effects, but when loading repositories
                                resolutionContext.setCredentials(uri, server.getUsername(),
                                        server.getPassword());
                            } else {
                                getLogger().info("Unknown server id=" + id + " for repository location="
                                        + repository.getLocation());
                            }
                        }

                        // TODO mirrors are no longer considered -> lookup mirrors when loading p2 repositories
                    }
                }
            } catch (URISyntaxException e) {
                throw new RuntimeException(e);
            }
        }

        try {
            getLogger().debug("Resolving target definition file \"" + configuration.getTarget() + "\"");
            resolutionContext.addTargetDefinition(target, getEnvironments(configuration));
        } catch (TargetDefinitionSyntaxException e) {
            throw new RuntimeException(
                    "Invalid syntax in target definition " + configuration.getTarget() + ": " + e.getMessage(),
                    e);
        } catch (TargetDefinitionResolutionException e) {
            throw new RuntimeException("Failed to resolve target definition " + configuration.getTarget(), e);
        }
    }
}