Examples with SimpleMavenCache gate.util.maven.SimpleMavenCache used on opensource projects

Example 1 with SimpleMavenCache

use of gate.util.maven.SimpleMavenCache in project gate-core by GateNLP.

the class PackageGappTask method execute.

@Override
public void execute() throws BuildException {
    // process the hints
    for (MappingHint h : hintTasks) {
        h.perform();
    }
    // map to store the necessary file copy operations
    Map<URL, URL> fileCopyMap = new HashMap<URL, URL>();
    Map<URL, URL> dirCopyMap = new HashMap<URL, URL>();
    TreeMap<URL, URL> pluginCopyMap = new TreeMap<URL, URL>(PATH_COMPARATOR);
    log("Packaging gapp file " + src);
    // do the work
    GappModel gappModel = null;
    URL newFileURL = null;
    try {
        URL gateHomeURL = null;
        // convert gateHome to a URL, if it was provided
        if (gateHome != null) {
            gateHomeURL = gateHome.toURI().toURL();
        }
        URL resourcesHomeURL = null;
        // convert resourcesHome to a URL, if it was provided
        if (resourcesHome != null) {
            resourcesHomeURL = resourcesHome.toURI().toURL();
        }
        gappModel = new GappModel(src.toURI().toURL(), gateHomeURL, resourcesHomeURL);
        newFileURL = destFile.toURI().toURL();
        gappModel.setGappFileURL(newFileURL);
    } catch (MalformedURLException e) {
        throw new BuildException("Couldn't convert src or dest file to URL", e, getLocation());
    }
    // we use TreeSet for these sets so we will process the paths
    // higher up the directory tree before paths pointing to their
    // subdirectories.
    Set<URL> plugins = new TreeSet<URL>(PATH_COMPARATOR);
    plugins.addAll(gappModel.getPluginURLs());
    Set<URL> resources = new TreeSet<URL>(PATH_COMPARATOR);
    resources.addAll(gappModel.getResourceURLs());
    // process the extraresourcespath elements (if any)
    processExtraResourcesPaths(resources);
    // first look at the explicit mapping hints
    if (mappingHints != null && !mappingHints.isEmpty()) {
        Iterator<URL> resourcesIt = resources.iterator();
        while (resourcesIt.hasNext()) {
            URL resource = resourcesIt.next();
            for (URL hint : mappingHints.keySet()) {
                String hintString = hint.toExternalForm();
                if (resource.equals(hint) || (hintString.endsWith("/") && resource.toExternalForm().startsWith(hintString))) {
                    // found this resource under this hint
                    log("Found resource " + resource + " under mapping hint URL " + hint, Project.MSG_VERBOSE);
                    String hintTarget = mappingHints.get(hint);
                    URL newResourceURL = null;
                    if (hintTarget == null) {
                        // hint asks to map to an absolute URL
                        log("  Converting to absolute URL", Project.MSG_VERBOSE);
                        newResourceURL = resource;
                    } else {
                        // construct the new URL relative to the hint target
                        try {
                            URL mappedHint = new URL(newFileURL, hintTarget);
                            String resourceRelpath = PersistenceManager.getRelativePath(hint, resource);
                            newResourceURL = new URL(mappedHint, resourceRelpath);
                            fileCopyMap.put(resource, newResourceURL);
                            if (copyResourceDirs) {
                                dirCopyMap.put(new URL(resource, "."), new URL(newResourceURL, "."));
                            }
                        } catch (MalformedURLException e) {
                            throw new BuildException("Couldn't construct URL relative to " + hintTarget + " for " + resource, e, getLocation());
                        }
                        log("  Relocating to " + newResourceURL, Project.MSG_VERBOSE);
                    }
                    // do the relocation
                    gappModel.updatePathForURL(resource, newResourceURL, hintTarget != null);
                    // we've now dealt with this resource, so don't need to
                    // handle it later
                    resourcesIt.remove();
                    break;
                }
            }
        }
    }
    // Any resources that aren't covered by the hints, try and
    // resolve them relative to the plugins referenced by the
    // application.
    Iterator<URL> pluginsIt = plugins.iterator();
    while (pluginsIt.hasNext()) {
        URL pluginURL = pluginsIt.next();
        pluginsIt.remove();
        URL newPluginURL = null;
        String pluginName = pluginURL.getFile();
        log("Processing plugin " + pluginName, Project.MSG_VERBOSE);
        // first check whether this plugin is a subdirectory of another plugin
        // we have already processed
        SortedMap<URL, URL> possibleAncestors = pluginCopyMap.headMap(pluginURL);
        URL ancestorPlugin = null;
        if (!possibleAncestors.isEmpty())
            ancestorPlugin = possibleAncestors.lastKey();
        if (ancestorPlugin != null && pluginURL.toExternalForm().startsWith(ancestorPlugin.toExternalForm())) {
            // this plugin is under one we have already dealt with
            log("  Plugin is located under another plugin " + ancestorPlugin, Project.MSG_VERBOSE);
            String relPath = PersistenceManager.getRelativePath(ancestorPlugin, pluginURL);
            try {
                newPluginURL = new URL(pluginCopyMap.get(ancestorPlugin), relPath);
            } catch (MalformedURLException e) {
                throw new BuildException("Couldn't construct URL relative to plugins/" + " for " + pluginURL, e, getLocation());
            }
        } else {
            // normal case, this plugin is not a subdir of another plugin
            boolean addSlash = false;
            // we will map the plugin whose directory name is X to plugins/X
            if (pluginName.endsWith("/")) {
                addSlash = true;
                pluginName = pluginName.substring(pluginName.lastIndexOf('/', pluginName.length() - 2) + 1, pluginName.length() - 1);
            } else {
                pluginName = pluginName.substring(pluginName.lastIndexOf('/') + 1);
            }
            log("  Plugin name is " + pluginName, Project.MSG_VERBOSE);
            try {
                newPluginURL = new URL(newFileURL, "plugins/" + pluginName + (addSlash ? "/" : ""));
                // until we find one that is available.
                if (pluginCopyMap.containsValue(newPluginURL)) {
                    int index = 2;
                    do {
                        newPluginURL = new URL(newFileURL, "plugins/" + pluginName + "-" + (index++) + (addSlash ? "/" : ""));
                    } while (pluginCopyMap.containsValue(newPluginURL));
                }
            } catch (MalformedURLException e) {
                throw new BuildException("Couldn't construct URL relative to plugins/" + " for " + pluginURL, e, getLocation());
            }
        }
        log("  Relocating to " + newPluginURL, Project.MSG_VERBOSE);
        // deal with the plugin URL itself (in the urlList)
        gappModel.updatePathForURL(pluginURL, newPluginURL, true);
        pluginCopyMap.put(pluginURL, newPluginURL);
        // now look for resources located under that plugin
        String pluginUri = pluginURL.toExternalForm();
        if (!pluginUri.endsWith("/")) {
            pluginUri += "/";
        }
        Iterator<URL> resourcesIt = resources.iterator();
        while (resourcesIt.hasNext()) {
            URL resourceURL = resourcesIt.next();
            try {
                if (resourceURL.toExternalForm().startsWith(pluginUri)) {
                    // found a resource under this plugin, so relocate it to be
                    // under the re-located plugin dir
                    resourcesIt.remove();
                    String resourceRelpath = PersistenceManager.getRelativePath(pluginURL, resourceURL);
                    log("    Found resource " + resourceURL, Project.MSG_VERBOSE);
                    URL newResourceURL = null;
                    newResourceURL = new URL(newPluginURL, resourceRelpath);
                    log("    Relocating to " + newResourceURL, Project.MSG_VERBOSE);
                    gappModel.updatePathForURL(resourceURL, newResourceURL, true);
                    fileCopyMap.put(resourceURL, newResourceURL);
                    if (copyResourceDirs) {
                        dirCopyMap.put(new URL(resourceURL, "."), new URL(newResourceURL, "."));
                    }
                }
            } catch (MalformedURLException e) {
                throw new BuildException("Couldn't construct URL relative to " + newPluginURL + " for " + resourceURL, e, getLocation());
            }
        }
    }
    // anything left over, handle according to onUnresolved
    if (!resources.isEmpty()) {
        switch(onUnresolved) {
            case fail:
                // easy case - fail the build
                log("There were unresolved resources:", Project.MSG_ERR);
                for (URL res : resources) {
                    log(res.toExternalForm(), Project.MSG_ERR);
                }
                log("Either set onUnresolved=\"absolute|recover\" or add the " + "relevant mapping hints", Project.MSG_ERR);
                throw new BuildException("There were unresolved resources", getLocation());
            case absolute:
                // convert all unresolved resources to absolute URLs
                log("There were unresolved resources, which have been made absolute", Project.MSG_WARN);
                for (URL res : resources) {
                    gappModel.updatePathForURL(res, res, false);
                    log(res.toExternalForm(), Project.MSG_VERBOSE);
                }
                break;
            case recover:
                // the clever case - recover by putting all the unresolved
                // resources into subdirectories of an "application-resources"
                // directory under the output dir
                URL unresolvedResourcesDir = null;
                try {
                    unresolvedResourcesDir = new URL(newFileURL, "application-resources/");
                } catch (MalformedURLException e) {
                    throw new BuildException("Can't construct URL relative to " + newFileURL + " for application-resources", e, getLocation());
                }
                // map to track where under application-resources we should map
                // each directory that contains unresolved resources
                TreeMap<URL, URL> unresolvedResourcesSubDirs = new TreeMap<URL, URL>(PATH_COMPARATOR);
                log("There were unresolved resources, which have been gathered into " + unresolvedResourcesDir, Project.MSG_INFO);
                for (URL res : resources) {
                    URL resourceDir = null;
                    try {
                        resourceDir = new URL(res, ".");
                    } catch (MalformedURLException e) {
                        throw new BuildException("Can't construct URL to parent directory of " + res, e, getLocation());
                    }
                    URL targetDir = getUnresolvedResourcesTarget(unresolvedResourcesSubDirs, unresolvedResourcesDir, resourceDir);
                    String resName = res.getFile();
                    resName = resName.substring(resName.lastIndexOf('/') + 1);
                    URL newResourceURL = null;
                    try {
                        newResourceURL = new URL(targetDir, resName);
                    } catch (MalformedURLException e) {
                        throw new BuildException("Can't construct URL relative to " + unresolvedResourcesDir + " for " + resName, e, getLocation());
                    }
                    gappModel.updatePathForURL(res, newResourceURL, true);
                    fileCopyMap.put(res, newResourceURL);
                    if (copyResourceDirs) {
                        dirCopyMap.put(resourceDir, targetDir);
                    }
                }
                break;
            default:
                throw new BuildException("Unrecognised UnresolvedAction", getLocation());
        }
    }
    // write out the fixed GAPP file
    try {
        log("Writing modified gapp to " + destFile);
        gappModel.write();
    } catch (IOException e) {
        throw new BuildException("Error writing out modified GAPP file", e, getLocation());
    }
    // now copy the files that it references
    if (fileCopyMap.size() > 0) {
        log("Copying " + fileCopyMap.size() + " resources");
    }
    for (Map.Entry<URL, URL> resEntry : fileCopyMap.entrySet()) {
        File source = Files.fileFromURL(resEntry.getKey());
        File dest = Files.fileFromURL(resEntry.getValue());
        if (source.isDirectory()) {
            // source URL points to a directory, so create a corresponding
            // directory dest
            dest.mkdirs();
        } else {
            // source URL doesn't point to a directory, so
            // ensure parent directory exists
            dest.getParentFile().mkdirs();
            if (source.isFile()) {
                // source URL points to an existing file, copy it
                try {
                    log("Copying " + source + " to " + dest, Project.MSG_VERBOSE);
                    FileUtils.getFileUtils().copyFile(source, dest);
                } catch (IOException e) {
                    throw new BuildException("Error copying file " + source + " to " + dest, e, getLocation());
                }
            }
        }
    }
    // handle the plugins
    if (pluginCopyMap.size() > 0) {
        log("Copying " + pluginCopyMap.size() + " plugins");
        if (copyPlugins) {
            log("Also copying complete plugin contents", Project.MSG_VERBOSE);
        }
        copyDirectories(pluginCopyMap, !copyPlugins);
    }
    // handle extra directories
    if (dirCopyMap.size() > 0) {
        log("Copying " + dirCopyMap.size() + " resource directories");
        copyDirectories(dirCopyMap, false);
    }
    if (mavenCache != null) {
        List<GappModel.MavenPlugin> mavenPlugins = gappModel.getMavenPlugins();
        if (!mavenPlugins.isEmpty()) {
            log("Creating Maven cache at " + mavenCache.getAbsolutePath());
            SimpleMavenCache smc = new SimpleMavenCache(mavenCache);
            for (GappModel.MavenPlugin plugin : mavenPlugins) {
                log("  Cacheing " + plugin.group + ":" + plugin.artifact + ":" + plugin.version, Project.MSG_VERBOSE);
                Artifact pluginArtifact = new DefaultArtifact(plugin.group, plugin.artifact, "jar", plugin.version);
                try {
                    smc.cacheArtifact(pluginArtifact);
                } catch (DependencyCollectionException | DependencyResolutionException | ArtifactResolutionException | IOException | SettingsBuildingException | ModelBuildingException e) {
                    throw new BuildException("Error cacheing plugin " + plugin.group + ":" + plugin.artifact + ":" + plugin.version, e);
                }
                // and the matching creole.jar if there is one
                try {
                    smc.cacheArtifact(new SubArtifact(pluginArtifact, "creole", "jar"));
                } catch (DependencyCollectionException | DependencyResolutionException | ArtifactResolutionException | IOException | SettingsBuildingException | ModelBuildingException e) {
                    log("    Could not cache " + plugin.group + ":" + plugin.artifact + "-" + plugin.version + "-creole.jar -  cache will still work but will " + "print warnings at runtime");
                }
            }
        }
    }
}