| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| package org.apache.ivy; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.net.MalformedURLException; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.net.URLClassLoader; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.StringTokenizer; |
| |
| import org.apache.ivy.core.cache.ResolutionCacheManager; |
| import org.apache.ivy.core.deliver.DeliverOptions; |
| import org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor; |
| import org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor; |
| import org.apache.ivy.core.module.descriptor.ModuleDescriptor; |
| import org.apache.ivy.core.module.id.ModuleRevisionId; |
| import org.apache.ivy.core.publish.PublishOptions; |
| import org.apache.ivy.core.report.ArtifactDownloadReport; |
| import org.apache.ivy.core.report.ResolveReport; |
| import org.apache.ivy.core.resolve.ResolveOptions; |
| import org.apache.ivy.core.resolve.ResolveProcessException; |
| import org.apache.ivy.core.retrieve.RetrieveOptions; |
| import org.apache.ivy.core.settings.IvySettings; |
| import org.apache.ivy.plugins.parser.m2.PomModuleDescriptorWriter; |
| import org.apache.ivy.plugins.parser.m2.PomWriterOptions; |
| import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorWriter; |
| import org.apache.ivy.plugins.report.XmlReportParser; |
| import org.apache.ivy.util.DefaultMessageLogger; |
| import org.apache.ivy.util.Message; |
| import org.apache.ivy.util.PropertiesFile; |
| import org.apache.ivy.util.cli.CommandLine; |
| import org.apache.ivy.util.cli.CommandLineParser; |
| import org.apache.ivy.util.cli.OptionBuilder; |
| import org.apache.ivy.util.cli.ParseException; |
| import org.apache.ivy.util.filter.FilterHelper; |
| import org.apache.ivy.util.url.CredentialsStore; |
| import org.apache.ivy.util.url.TimeoutConstrainedURLHandler; |
| import org.apache.ivy.util.url.URLHandlerDispatcher; |
| import org.apache.ivy.util.url.URLHandlerRegistry; |
| |
| /** |
| * Class used to launch ivy as a standalone tool. |
| * <p> |
| * Valid arguments can be obtained with the -? argument. |
| */ |
| public final class Main { |
| private static final int HELP_WIDTH = 80; |
| |
| static CommandLineParser getParser() { |
| return new CommandLineParser() |
| .addCategory("settings options") |
| .addOption( |
| new OptionBuilder("settings").arg("settingsfile|url") |
| .description("use given file or URL for settings").create()) |
| .addOption( |
| new OptionBuilder("properties").arg("propertiesfile") |
| .description("use given file for properties not specified in settings").create()) |
| .addOption( |
| new OptionBuilder("cache").arg("cachedir") |
| .description("use given directory for cache").create()) |
| .addOption( |
| new OptionBuilder("novalidate").description( |
| "do not validate ivy files against xsd").create()) |
| .addOption( |
| new OptionBuilder("m2compatible").description("use Maven 2 compatibility") |
| .create()) |
| .addOption( |
| new OptionBuilder("conf").arg("settingsfile").deprecated() |
| .description("use given file for settings").create()) |
| .addOption( |
| new OptionBuilder("useOrigin") |
| .deprecated() |
| .description( |
| "use original artifact location " |
| + "with local resolvers instead of copying to the cache") |
| .create()) |
| |
| .addCategory("resolve options") |
| .addOption( |
| new OptionBuilder("ivy").arg("ivyfile") |
| .description("use given file as ivy file").create()) |
| .addOption( |
| new OptionBuilder("refresh").description("refresh dynamic resolved revisions") |
| .create()) |
| .addOption( |
| new OptionBuilder("dependency") |
| .arg("organisation") |
| .arg("module") |
| .arg("revision") |
| .description( |
| "use this instead of ivy file to do the rest " |
| + "of the work with this as a dependency.").create()) |
| .addOption( |
| new OptionBuilder("confs").arg("configurations").countArgs(false) |
| .description("resolve given configurations").create()) |
| .addOption( |
| new OptionBuilder("types").arg("types").countArgs(false) |
| .description("accepted artifact types") |
| .create()) |
| .addOption( |
| new OptionBuilder("mode").arg("resolvemode") |
| .description("the resolve mode to use").create()) |
| .addOption( |
| new OptionBuilder("notransitive").description( |
| "do not resolve dependencies transitively").create()) |
| |
| .addCategory("retrieve options") |
| .addOption( |
| new OptionBuilder("retrieve").arg("retrievepattern") |
| .description("use given pattern as retrieve pattern").create()) |
| .addOption( |
| new OptionBuilder("ivypattern").arg("pattern") |
| .description("use given pattern to copy the ivy files").create()) |
| .addOption( |
| new OptionBuilder("sync").description("use sync mode for retrieve").create()) |
| .addOption( |
| new OptionBuilder("symlink").description("create symbolic links").create()) |
| .addOption(new OptionBuilder("overwriteMode").arg("overwriteMode") |
| .description("use given overwrite mode for retrieve") |
| .create()) |
| .addCategory("cache path options") |
| .addOption( |
| new OptionBuilder("cachepath") |
| .arg("cachepathfile") |
| .description( |
| "outputs a classpath consisting of all dependencies in cache " |
| + "(including transitive ones) " |
| + "of the given ivy file to the given cachepathfile") |
| .create()) |
| |
| .addCategory("deliver options") |
| .addOption( |
| new OptionBuilder("deliverto").arg("ivypattern") |
| .description("use given pattern as resolved ivy file pattern").create()) |
| |
| .addCategory("publish options") |
| .addOption( |
| new OptionBuilder("publish").arg("resolvername") |
| .description("use given resolver to publish to").create()) |
| .addOption( |
| new OptionBuilder("publishpattern").arg("artpattern") |
| .description("use given pattern to find artifacts to publish").create()) |
| .addOption( |
| new OptionBuilder("revision").arg("revision") |
| .description("use given revision to publish the module").create()) |
| .addOption( |
| new OptionBuilder("status").arg("status") |
| .description("use given status to publish the module").create()) |
| .addOption( |
| new OptionBuilder("overwrite").description( |
| "overwrite files in the repository if they exist").create()) |
| |
| .addCategory("makepom options") |
| .addOption(new OptionBuilder("makepom").arg("pomfilepath") |
| .description("create a POM file for the module").create()) |
| |
| .addCategory("http auth options") |
| .addOption( |
| new OptionBuilder("realm").arg("realm") |
| .description("use given realm for HTTP AUTH").create()) |
| .addOption( |
| new OptionBuilder("host").arg("host") |
| .description("use given host for HTTP AUTH").create()) |
| .addOption( |
| new OptionBuilder("username").arg("username") |
| .description("use given username for HTTP AUTH").create()) |
| .addOption( |
| new OptionBuilder("passwd").arg("passwd") |
| .description("use given password for HTTP AUTH").create()) |
| |
| .addCategory("launcher options") |
| .addOption( |
| new OptionBuilder("main").arg("main") |
| .description("the FQCN of the main class to launch").create()) |
| .addOption( |
| new OptionBuilder("args").arg("args").countArgs(false) |
| .description("the arguments to give to the launched process").create()) |
| .addOption( |
| new OptionBuilder("cp").arg("cp") |
| .description("extra classpath to use when launching process").create()) |
| |
| |
| .addCategory("message options") |
| .addOption( |
| new OptionBuilder("debug").description("set message level to debug").create()) |
| .addOption( |
| new OptionBuilder("verbose").description("set message level to verbose") |
| .create()) |
| .addOption( |
| new OptionBuilder("warn").description("set message level to warn").create()) |
| .addOption( |
| new OptionBuilder("error").description("set message level to error").create()) |
| |
| .addCategory("help options") |
| .addOption(new OptionBuilder("?").description("display this help").create()) |
| .addOption( |
| new OptionBuilder("deprecated").description("show deprecated options").create()) |
| .addOption( |
| new OptionBuilder("version").description("displays version information") |
| .create()); |
| } |
| |
| public static void main(String[] args) throws Exception { |
| try { |
| run(args, true); |
| System.exit(0); |
| } catch (ParseException ex) { |
| System.err.println(ex.getMessage()); |
| System.exit(1); |
| } |
| } |
| |
| /** |
| * A method that allows to run embedded Ivy as if it were launched from CLI |
| * (e.g., for use with REPL in Java 9+). |
| * |
| * @param args an array of command line arguments |
| * @return null if asked for usage or version, or if anything fails during resolve, publish or |
| * launch; a ResolveReport on success |
| * @throws Exception if something goes wrong |
| */ |
| public static ResolveReport run(String[] args) throws Exception { |
| return run(args, false); |
| } |
| |
| /* |
| * For backwards compatibility and testing |
| */ |
| static void run(CommandLineParser parser, String[] args) throws Exception { |
| if (Arrays.asList(args).contains("-?")) { |
| usage(parser, false); |
| return; |
| } |
| |
| run(parser.parse(args), true); |
| } |
| |
| private static ResolveReport run(String[] args, boolean isCli) throws Exception { |
| CommandLineParser parser = getParser(); |
| |
| // parse the command line arguments |
| CommandLine line; |
| try { |
| line = parser.parse(args); |
| } catch (ParseException pe) { |
| // display usage and and rethrow |
| usage(parser, false); |
| throw new ParseException(pe.getMessage()); |
| } |
| |
| if (line.hasOption("?")) { |
| usage(parser, line.hasOption("deprecated")); |
| return null; |
| } |
| |
| return run(line, isCli); |
| } |
| |
| @SuppressWarnings("deprecation") |
| private static ResolveReport run(CommandLine line, boolean isCli) throws Exception { |
| if (line.hasOption("version")) { |
| System.out.println("Apache Ivy " + Ivy.getIvyVersion() + " - " + Ivy.getIvyDate() |
| + " :: " + Ivy.getIvyHomeURL()); |
| return null; |
| } |
| |
| boolean validate = !line.hasOption("novalidate"); |
| |
| Ivy ivy = Ivy.newInstance(); |
| initMessage(line, ivy); |
| IvySettings settings = initSettings(line, ivy); |
| ivy.pushContext(); |
| |
| File cache = new File(settings.substitute(line.getOptionValue("cache", settings |
| .getDefaultCache().getAbsolutePath()))); |
| |
| if (line.hasOption("cache")) { |
| // override default cache path with user supplied cache path |
| settings.setDefaultCache(cache); |
| } |
| |
| if (!cache.exists()) { |
| cache.mkdirs(); |
| } else if (!cache.isDirectory()) { |
| error(cache + " is not a directory"); |
| } |
| |
| String[] confs; |
| if (line.hasOption("confs")) { |
| confs = line.getOptionValues("confs"); |
| } else { |
| confs = new String[] {"*"}; |
| } |
| |
| File ivyfile; |
| if (line.hasOption("dependency")) { |
| String[] dep = line.getOptionValues("dependency"); |
| ivyfile = File.createTempFile("ivy", ".xml"); |
| ivyfile.deleteOnExit(); |
| DefaultModuleDescriptor md = DefaultModuleDescriptor |
| .newDefaultInstance(ModuleRevisionId.newInstance(dep[0], dep[1] + "-caller", |
| "working")); |
| DefaultDependencyDescriptor dd = new DefaultDependencyDescriptor(md, |
| ModuleRevisionId.newInstance(dep[0], dep[1], dep[2]), false, false, true); |
| for (String conf : confs) { |
| dd.addDependencyConfiguration("default", conf); |
| } |
| md.addDependency(dd); |
| XmlModuleDescriptorWriter.write(md, ivyfile); |
| confs = new String[] {"default"}; |
| } else { |
| ivyfile = new File(settings.substitute(line.getOptionValue("ivy", "ivy.xml"))); |
| if (!ivyfile.exists()) { |
| error("ivy file not found: " + ivyfile); |
| } else if (ivyfile.isDirectory()) { |
| error("ivy file is not a file: " + ivyfile); |
| } |
| } |
| |
| if (line.hasOption("useOrigin")) { |
| ivy.getSettings().useDeprecatedUseOrigin(); |
| } |
| ResolveOptions resolveOptions = new ResolveOptions() |
| .setConfs(confs) |
| .setValidate(validate) |
| .setResolveMode(line.getOptionValue("mode")) |
| .setArtifactFilter( |
| FilterHelper.getArtifactTypeFilter(line.getOptionValues("types"))); |
| if (line.hasOption("notransitive")) { |
| resolveOptions.setTransitive(false); |
| } |
| if (line.hasOption("refresh")) { |
| resolveOptions.setRefresh(true); |
| } |
| ResolveReport report = ivy.resolve(ivyfile.toURI().toURL(), resolveOptions); |
| if (report.hasError()) { |
| if (isCli) { |
| System.exit(1); |
| } |
| |
| StringBuilder sb = new StringBuilder(); |
| for (String problem : report.getAllProblemMessages()) { |
| if (sb.length() > 0) { |
| sb.append("\n"); |
| } |
| sb.append(problem); |
| } |
| throw new ResolveProcessException(sb.toString()); |
| } |
| ModuleDescriptor md = report.getModuleDescriptor(); |
| |
| if (confs.length == 1 && "*".equals(confs[0])) { |
| confs = md.getConfigurationsNames(); |
| } |
| if (line.hasOption("retrieve")) { |
| String retrievePattern = settings.substitute(line.getOptionValue("retrieve")); |
| if (!retrievePattern.contains("[")) { |
| retrievePattern += "/lib/[conf]/[artifact].[ext]"; |
| } |
| String ivyPattern = settings.substitute(line.getOptionValue("ivypattern")); |
| ivy.retrieve( |
| md.getModuleRevisionId(), |
| new RetrieveOptions() |
| .setConfs(confs) |
| .setSync(line.hasOption("sync")) |
| .setUseOrigin(line.hasOption("useOrigin")) |
| .setDestArtifactPattern(retrievePattern) |
| .setDestIvyPattern(ivyPattern) |
| .setOverwriteMode(line.getOptionValue("overwriteMode")) |
| .setArtifactFilter( |
| FilterHelper.getArtifactTypeFilter(line.getOptionValues("types"))) |
| .setMakeSymlinks(line.hasOption("symlink")) |
| .setMakeSymlinksInMass(line.hasOption("symlinkmass"))); |
| } |
| if (line.hasOption("cachepath")) { |
| outputCachePath(ivy, cache, md, confs, |
| line.getOptionValue("cachepath", "ivycachepath.txt")); |
| } |
| |
| if (line.hasOption("revision")) { |
| ivy.deliver( |
| md.getResolvedModuleRevisionId(), |
| settings.substitute(line.getOptionValue("revision")), |
| settings.substitute(line.getOptionValue("deliverto", "ivy-[revision].xml")), |
| DeliverOptions.newInstance(settings) |
| .setStatus(settings.substitute(line.getOptionValue("status", "release"))) |
| .setValidate(validate)); |
| if (line.hasOption("publish")) { |
| ivy.publish( |
| md.getResolvedModuleRevisionId(), |
| Collections.singleton(settings.substitute(line.getOptionValue("publishpattern", |
| "distrib/[type]s/[artifact]-[revision].[ext]"))), |
| line.getOptionValue("publish"), |
| new PublishOptions() |
| .setPubrevision(settings.substitute(line.getOptionValue("revision"))) |
| .setValidate(validate) |
| .setSrcIvyPattern( |
| settings.substitute(line.getOptionValue("deliverto", |
| "ivy-[revision].xml"))) |
| .setOverwrite(line.hasOption("overwrite"))); |
| } |
| } |
| if (line.hasOption("makepom")) { |
| final String pomFilePath = line.getOptionValue("makepom", "pom.xml"); |
| final File pomFile = new File(pomFilePath); |
| PomModuleDescriptorWriter.write(md, pomFile, new PomWriterOptions()); |
| Message.debug("Generated a pom file for module at " + pomFile); |
| } |
| if (line.hasOption("main")) { |
| // check if the option cp has been set |
| List<File> fileList = getExtraClasspathFileList(line); |
| |
| // merge -args and left over args |
| String[] fargs = line.getOptionValues("args"); |
| if (fargs == null) { |
| fargs = new String[0]; |
| } |
| String[] extra = line.getLeftOverArgs(); |
| if (extra == null) { |
| extra = new String[0]; |
| } |
| String[] params = new String[fargs.length + extra.length]; |
| System.arraycopy(fargs, 0, params, 0, fargs.length); |
| System.arraycopy(extra, 0, params, fargs.length, extra.length); |
| // invoke with given main class and merged params |
| invoke(ivy, cache, md, confs, fileList, line.getOptionValue("main"), params); |
| } |
| ivy.getLoggerEngine().popLogger(); |
| ivy.popContext(); |
| |
| return report; |
| } |
| |
| /** |
| * Parses the <code>cp</code> option from the command line, and returns a list of {@link File}. |
| * <p> |
| * All the files contained in the returned List exist, non existing files are simply skipped |
| * with a warning. |
| * </p> |
| * |
| * @param line |
| * the command line in which the cp option should be parsed |
| * @return a List of files to include as extra classpath entries, or <code>null</code> if no cp |
| * option was provided. |
| */ |
| private static List<File> getExtraClasspathFileList(CommandLine line) { |
| List<File> fileList = null; |
| if (line.hasOption("cp")) { |
| fileList = new ArrayList<>(); |
| for (String cp : line.getOptionValues("cp")) { |
| StringTokenizer tokenizer = new StringTokenizer(cp, File.pathSeparator); |
| while (tokenizer.hasMoreTokens()) { |
| String token = tokenizer.nextToken(); |
| File file = new File(token); |
| if (file.exists()) { |
| fileList.add(file); |
| } else { |
| Message.warn("Skipping extra classpath '" + file |
| + "' as it does not exist."); |
| } |
| } |
| } |
| } |
| return fileList; |
| } |
| |
| private static IvySettings initSettings(CommandLine line, Ivy ivy) |
| throws java.text.ParseException, IOException, ParseException { |
| IvySettings settings = ivy.getSettings(); |
| settings.addAllVariables(System.getProperties()); |
| if (line.hasOption("properties")) { |
| settings.addAllVariables(new PropertiesFile(new File(line.getOptionValue("properties")), |
| "additional properties")); |
| } |
| if (line.hasOption("m2compatible")) { |
| settings.setVariable("ivy.default.configuration.m2compatible", "true"); |
| } |
| |
| configureURLHandler(line.getOptionValue("realm", null), line.getOptionValue("host", null), |
| line.getOptionValue("username", null), line.getOptionValue("passwd", null)); |
| |
| String settingsPath = line.getOptionValue("settings", ""); |
| if ("".equals(settingsPath)) { |
| settingsPath = line.getOptionValue("conf", ""); |
| if (!"".equals(settingsPath)) { |
| Message.deprecated("-conf is deprecated, use -settings instead"); |
| } |
| } |
| if ("".equals(settingsPath)) { |
| ivy.configureDefault(); |
| } else { |
| final URI confUri = getSettingsURI(settingsPath); |
| if ("file".equals(confUri.getScheme())) { |
| File conffile = new File(confUri); |
| if (!conffile.exists()) { |
| throw new IOException("ivy configuration file not found: " + conffile); |
| } else if (conffile.isDirectory()) { |
| throw new IOException("ivy configuration file is not a file: " + conffile); |
| } |
| ivy.configure(conffile); |
| } else { |
| try { |
| ivy.configure(confUri.toURL()); |
| } catch (IOException ioe) { |
| throw new IOException("ivy configuration failed to load from: " + settingsPath, ioe); |
| } |
| } |
| } |
| return settings; |
| } |
| |
| private static URI getSettingsURI(String settingsPath) { |
| URI settingsUri; |
| try { |
| settingsUri = new URI(settingsPath); |
| if (settingsUri.getScheme() == null) { |
| settingsUri = new File(settingsPath).toURI(); |
| } |
| } catch (URISyntaxException badUriEx) { |
| return new File(settingsPath).toURI(); |
| } |
| return settingsUri; |
| } |
| |
| private static void initMessage(CommandLine line, Ivy ivy) { |
| if (line.hasOption("debug")) { |
| ivy.getLoggerEngine().pushLogger(new DefaultMessageLogger(Message.MSG_DEBUG)); |
| } else if (line.hasOption("verbose")) { |
| ivy.getLoggerEngine().pushLogger(new DefaultMessageLogger(Message.MSG_VERBOSE)); |
| } else if (line.hasOption("warn")) { |
| ivy.getLoggerEngine().pushLogger(new DefaultMessageLogger(Message.MSG_WARN)); |
| } else if (line.hasOption("error")) { |
| ivy.getLoggerEngine().pushLogger(new DefaultMessageLogger(Message.MSG_ERR)); |
| } else { |
| ivy.getLoggerEngine().pushLogger(new DefaultMessageLogger(Message.MSG_INFO)); |
| } |
| } |
| |
| private static void outputCachePath(Ivy ivy, File cache, ModuleDescriptor md, String[] confs, |
| String outFile) { |
| try { |
| StringBuilder buf = new StringBuilder(); |
| Collection<ArtifactDownloadReport> all = new LinkedHashSet<>(); |
| ResolutionCacheManager cacheMgr = ivy.getResolutionCacheManager(); |
| XmlReportParser parser = new XmlReportParser(); |
| for (String conf : confs) { |
| String resolveId = ResolveOptions.getDefaultResolveId(md); |
| File report = cacheMgr.getConfigurationResolveReportInCache(resolveId, conf); |
| parser.parse(report); |
| |
| all.addAll(Arrays.asList(parser.getArtifactReports())); |
| } |
| for (ArtifactDownloadReport artifact : all) { |
| if (artifact.getLocalFile() != null) { |
| buf.append(artifact.getLocalFile().getCanonicalPath()); |
| buf.append(File.pathSeparator); |
| } |
| } |
| |
| PrintWriter writer = new PrintWriter(new FileOutputStream(outFile)); |
| if (buf.length() > 0) { |
| buf.setLength(buf.length() - File.pathSeparator.length()); |
| writer.println(buf); |
| } |
| writer.close(); |
| System.out.println("cachepath output to " + outFile); |
| |
| } catch (Exception ex) { |
| throw new RuntimeException("impossible to build ivy cache path: " + ex.getMessage(), ex); |
| } |
| } |
| |
| @SuppressWarnings("resource") |
| private static void invoke(Ivy ivy, File cache, ModuleDescriptor md, String[] confs, |
| List<File> fileList, String mainclass, String[] args) { |
| List<URL> urls = new ArrayList<>(); |
| |
| // Add option cp (extra classpath) urls |
| if (fileList != null && fileList.size() > 0) { |
| for (File file : fileList) { |
| try { |
| urls.add(file.toURI().toURL()); |
| } catch (MalformedURLException e) { |
| // Should not happen, just ignore. |
| } |
| } |
| } |
| |
| try { |
| Collection<ArtifactDownloadReport> all = new LinkedHashSet<>(); |
| ResolutionCacheManager cacheMgr = ivy.getResolutionCacheManager(); |
| XmlReportParser parser = new XmlReportParser(); |
| for (String conf : confs) { |
| String resolveId = ResolveOptions.getDefaultResolveId(md); |
| File report = cacheMgr.getConfigurationResolveReportInCache(resolveId, conf); |
| parser.parse(report); |
| |
| all.addAll(Arrays.asList(parser.getArtifactReports())); |
| } |
| for (ArtifactDownloadReport artifact : all) { |
| if (artifact.getLocalFile() != null) { |
| urls.add(artifact.getLocalFile().toURI().toURL()); |
| } |
| } |
| } catch (Exception ex) { |
| throw new RuntimeException("impossible to build ivy cache path: " + ex.getMessage(), ex); |
| } |
| |
| URLClassLoader classLoader = new URLClassLoader(urls.toArray(new URL[urls.size()]), |
| Main.class.getClassLoader().getParent()); |
| |
| try { |
| Class<?> c = classLoader.loadClass(mainclass); |
| |
| Method mainMethod = c.getMethod("main", String[].class); |
| |
| Thread.currentThread().setContextClassLoader(classLoader); |
| mainMethod.invoke(null, new Object[] {(args == null ? new String[0] : args)}); |
| } catch (ClassNotFoundException cnfe) { |
| throw new RuntimeException("Could not find class: " + mainclass, cnfe); |
| } catch (SecurityException | NoSuchMethodException e) { |
| throw new RuntimeException("Could not find main method: " + mainclass, e); |
| } catch (IllegalAccessException e) { |
| throw new RuntimeException("No permissions to invoke main method: " + mainclass, e); |
| } catch (InvocationTargetException e) { |
| throw new RuntimeException("Unexpected exception invoking main method: " + mainclass, e); |
| } |
| } |
| |
| private static void configureURLHandler(String realm, String host, String username, |
| String passwd) { |
| CredentialsStore.INSTANCE.addCredentials(realm, host, username, passwd); |
| |
| URLHandlerDispatcher dispatcher = new URLHandlerDispatcher(); |
| TimeoutConstrainedURLHandler httpHandler = URLHandlerRegistry.getHttp(); |
| dispatcher.setDownloader("http", httpHandler); |
| dispatcher.setDownloader("https", httpHandler); |
| URLHandlerRegistry.setDefault(dispatcher); |
| } |
| |
| private static void error(String msg) throws ParseException { |
| throw new ParseException(msg); |
| } |
| |
| private static void usage(CommandLineParser parser, boolean showDeprecated) { |
| // automatically generate the help statement |
| PrintWriter pw = new PrintWriter(System.out); |
| parser.printHelp(pw, HELP_WIDTH, "ivy", showDeprecated); |
| pw.flush(); |
| } |
| |
| private Main() { |
| } |
| } |
