| | |
|---|
| | | */ |
|---|
| | | package com.gitblit.manager; |
|---|
| | | |
|---|
| | | import java.io.BufferedInputStream; |
|---|
| | | import java.io.File; |
|---|
| | | import java.io.FileFilter; |
|---|
| | | import java.io.FileInputStream; |
|---|
| | | import java.io.IOException; |
|---|
| | | import java.io.InputStream; |
|---|
| | | import java.net.HttpURLConnection; |
|---|
| | | import java.net.Proxy; |
|---|
| | | import java.net.URL; |
|---|
| | | import java.net.URLConnection; |
|---|
| | | import java.security.DigestInputStream; |
|---|
| | | import java.security.MessageDigest; |
|---|
| | | import java.security.NoSuchAlgorithmException; |
|---|
| | | import java.util.ArrayList; |
|---|
| | | import java.util.Iterator; |
|---|
| | | import java.util.List; |
|---|
| | | import java.util.Map; |
|---|
| | | import java.util.TreeMap; |
|---|
| | | |
|---|
| | | import javax.inject.Inject; |
|---|
| | | |
|---|
| | | import org.slf4j.Logger; |
|---|
| | | import org.slf4j.LoggerFactory; |
|---|
| | | |
|---|
| | | import ro.fortsoft.pf4j.DefaultPluginManager; |
|---|
| | | import ro.fortsoft.pf4j.PluginClassLoader; |
|---|
| | | import ro.fortsoft.pf4j.PluginState; |
|---|
| | | import ro.fortsoft.pf4j.PluginStateEvent; |
|---|
| | | import ro.fortsoft.pf4j.PluginStateListener; |
|---|
| | | import ro.fortsoft.pf4j.PluginWrapper; |
|---|
| | | import ro.fortsoft.pf4j.Version; |
|---|
| | | |
|---|
| | | import com.gitblit.Constants; |
|---|
| | | import com.gitblit.Keys; |
|---|
| | | import com.gitblit.extensions.GitblitPlugin; |
|---|
| | | import com.gitblit.models.PluginRegistry; |
|---|
| | | import com.gitblit.models.PluginRegistry.InstallState; |
|---|
| | | import com.gitblit.models.PluginRegistry.PluginRegistration; |
|---|
| | | import com.gitblit.models.PluginRegistry.PluginRelease; |
|---|
| | | import com.gitblit.utils.Base64; |
|---|
| | | import com.gitblit.utils.FileUtils; |
|---|
| | | import com.gitblit.utils.JsonUtils; |
|---|
| | | import com.gitblit.utils.StringUtils; |
|---|
| | | import com.google.common.io.Files; |
|---|
| | | import com.google.common.io.InputSupplier; |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * The plugin manager maintains the lifecycle of plugins. It is exposed as |
|---|
| | | * Dagger bean. The extension consumers supposed to retrieve plugin manager |
|---|
| | | * from the Dagger DI and retrieve extensions provided by active plugins. |
|---|
| | | * |
|---|
| | | * Dagger bean. The extension consumers supposed to retrieve plugin manager from |
|---|
| | | * the Dagger DI and retrieve extensions provided by active plugins. |
|---|
| | | * |
|---|
| | | * @author David Ostrovsky |
|---|
| | | * |
|---|
| | | * @author James Moger |
|---|
| | | * |
|---|
| | | */ |
|---|
| | | public class PluginManager extends DefaultPluginManager implements |
|---|
| | | IPluginManager { |
|---|
| | | public class PluginManager implements IPluginManager, PluginStateListener { |
|---|
| | | |
|---|
| | | private final Logger logger = LoggerFactory.getLogger(getClass()); |
|---|
| | | |
|---|
| | | private final DefaultPluginManager pf4j; |
|---|
| | | |
|---|
| | | private final IRuntimeManager runtimeManager; |
|---|
| | | |
|---|
| | | // timeout defaults of Maven 3.0.4 in seconds |
|---|
| | | private int connectTimeout = 20; |
|---|
| | | |
|---|
| | | private int readTimeout = 12800; |
|---|
| | | |
|---|
| | | @Inject |
|---|
| | | public PluginManager(IRuntimeManager runtimeManager) { |
|---|
| | | super(runtimeManager.getFileOrFolder(Keys.plugins.folder, |
|---|
| | | "${baseFolder}/plugins")); |
|---|
| | | File dir = runtimeManager.getFileOrFolder(Keys.plugins.folder, "${baseFolder}/plugins"); |
|---|
| | | dir.mkdirs(); |
|---|
| | | this.runtimeManager = runtimeManager; |
|---|
| | | |
|---|
| | | this.pf4j = new DefaultPluginManager(dir); |
|---|
| | | |
|---|
| | | try { |
|---|
| | | Version systemVersion = Version.createVersion(Constants.getVersion()); |
|---|
| | | pf4j.setSystemVersion(systemVersion); |
|---|
| | | } catch (Exception e) { |
|---|
| | | logger.error(null, e); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public Version getSystemVersion() { |
|---|
| | | return pf4j.getSystemVersion(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public void pluginStateChanged(PluginStateEvent event) { |
|---|
| | | logger.debug(event.toString()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public PluginManager start() { |
|---|
| | | logger.info("Plugin manager started"); |
|---|
| | | loadPlugins(); |
|---|
| | | startPlugins(); |
|---|
| | | pf4j.loadPlugins(); |
|---|
| | | logger.debug("Starting plugins"); |
|---|
| | | pf4j.startPlugins(); |
|---|
| | | return this; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public PluginManager stop() { |
|---|
| | | stopPlugins(); |
|---|
| | | logger.debug("Stopping plugins"); |
|---|
| | | pf4j.stopPlugins(); |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Installs the plugin from the url. |
|---|
| | | * |
|---|
| | | * @param url |
|---|
| | | * @param verifyChecksum |
|---|
| | | * @return true if successful |
|---|
| | | */ |
|---|
| | | @Override |
|---|
| | | public synchronized boolean installPlugin(String url, boolean verifyChecksum) throws IOException { |
|---|
| | | File file = download(url, verifyChecksum); |
|---|
| | | if (file == null || !file.exists()) { |
|---|
| | | logger.error("Failed to download plugin {}", url); |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | String pluginId = pf4j.loadPlugin(file); |
|---|
| | | if (StringUtils.isEmpty(pluginId)) { |
|---|
| | | logger.error("Failed to load plugin {}", file); |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | // allow the plugin to prepare for operation after installation |
|---|
| | | PluginWrapper pluginWrapper = pf4j.getPlugin(pluginId); |
|---|
| | | if (pluginWrapper.getPlugin() instanceof GitblitPlugin) { |
|---|
| | | ((GitblitPlugin) pluginWrapper.getPlugin()).onInstall(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | PluginState state = pf4j.startPlugin(pluginId); |
|---|
| | | return PluginState.STARTED.equals(state); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized boolean upgradePlugin(String pluginId, String url, boolean verifyChecksum) throws IOException { |
|---|
| | | // ensure we can download the update BEFORE we remove the existing one |
|---|
| | | File file = download(url, verifyChecksum); |
|---|
| | | if (file == null || !file.exists()) { |
|---|
| | | logger.error("Failed to download plugin {}", url); |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | Version oldVersion = pf4j.getPlugin(pluginId).getDescriptor().getVersion(); |
|---|
| | | if (removePlugin(pluginId, false)) { |
|---|
| | | String newPluginId = pf4j.loadPlugin(file); |
|---|
| | | if (StringUtils.isEmpty(newPluginId)) { |
|---|
| | | logger.error("Failed to load plugin {}", file); |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | // the plugin to handle an upgrade |
|---|
| | | PluginWrapper pluginWrapper = pf4j.getPlugin(newPluginId); |
|---|
| | | if (pluginWrapper.getPlugin() instanceof GitblitPlugin) { |
|---|
| | | ((GitblitPlugin) pluginWrapper.getPlugin()).onUpgrade(oldVersion); |
|---|
| | | } |
|---|
| | | |
|---|
| | | PluginState state = pf4j.startPlugin(newPluginId); |
|---|
| | | return PluginState.STARTED.equals(state); |
|---|
| | | } else { |
|---|
| | | logger.error("Failed to delete plugin {}", pluginId); |
|---|
| | | } |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized boolean disablePlugin(String pluginId) { |
|---|
| | | return pf4j.disablePlugin(pluginId); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized boolean enablePlugin(String pluginId) { |
|---|
| | | if (pf4j.enablePlugin(pluginId)) { |
|---|
| | | return PluginState.STARTED == pf4j.startPlugin(pluginId); |
|---|
| | | } |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized boolean uninstallPlugin(String pluginId) { |
|---|
| | | return removePlugin(pluginId, true); |
|---|
| | | } |
|---|
| | | |
|---|
| | | protected boolean removePlugin(String pluginId, boolean isUninstall) { |
|---|
| | | PluginWrapper pluginWrapper = getPlugin(pluginId); |
|---|
| | | final String name = pluginWrapper.getPluginPath().substring(1); |
|---|
| | | |
|---|
| | | if (isUninstall) { |
|---|
| | | // allow the plugin to prepare for uninstallation |
|---|
| | | if (pluginWrapper.getPlugin() instanceof GitblitPlugin) { |
|---|
| | | ((GitblitPlugin) pluginWrapper.getPlugin()).onUninstall(); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | if (pf4j.deletePlugin(pluginId)) { |
|---|
| | | |
|---|
| | | // delete the checksums |
|---|
| | | File pFolder = runtimeManager.getFileOrFolder(Keys.plugins.folder, "${baseFolder}/plugins"); |
|---|
| | | File [] checksums = pFolder.listFiles(new FileFilter() { |
|---|
| | | @Override |
|---|
| | | public boolean accept(File file) { |
|---|
| | | if (!file.isFile()) { |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | return file.getName().startsWith(name) && |
|---|
| | | (file.getName().toLowerCase().endsWith(".sha1") |
|---|
| | | || file.getName().toLowerCase().endsWith(".md5")); |
|---|
| | | } |
|---|
| | | }); |
|---|
| | | |
|---|
| | | if (checksums != null) { |
|---|
| | | for (File checksum : checksums) { |
|---|
| | | checksum.delete(); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return true; |
|---|
| | | } |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized PluginState startPlugin(String pluginId) { |
|---|
| | | return pf4j.startPlugin(pluginId); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized PluginState stopPlugin(String pluginId) { |
|---|
| | | return pf4j.stopPlugin(pluginId); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized void startPlugins() { |
|---|
| | | pf4j.startPlugins(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized void stopPlugins() { |
|---|
| | | pf4j.stopPlugins(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized List<PluginWrapper> getPlugins() { |
|---|
| | | return pf4j.getPlugins(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized PluginWrapper getPlugin(String pluginId) { |
|---|
| | | return pf4j.getPlugin(pluginId); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized List<Class<?>> getExtensionClasses(String pluginId) { |
|---|
| | | List<Class<?>> list = new ArrayList<Class<?>>(); |
|---|
| | | PluginClassLoader loader = pf4j.getPluginClassLoader(pluginId); |
|---|
| | | for (String className : pf4j.getExtensionClassNames(pluginId)) { |
|---|
| | | try { |
|---|
| | | list.add(loader.loadClass(className)); |
|---|
| | | } catch (ClassNotFoundException e) { |
|---|
| | | logger.error(String.format("Failed to find %s in %s", className, pluginId), e); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return list; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized <T> List<T> getExtensions(Class<T> type) { |
|---|
| | | return pf4j.getExtensions(type); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized PluginWrapper whichPlugin(Class<?> clazz) { |
|---|
| | | return pf4j.whichPlugin(clazz); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized boolean refreshRegistry(boolean verifyChecksum) { |
|---|
| | | String dr = "http://gitblit.github.io/gitblit-registry/plugins.json"; |
|---|
| | | String url = runtimeManager.getSettings().getString(Keys.plugins.registry, dr); |
|---|
| | | try { |
|---|
| | | File file = download(url, verifyChecksum); |
|---|
| | | if (file != null && file.exists()) { |
|---|
| | | URL selfUrl = new URL(url.substring(0, url.lastIndexOf('/'))); |
|---|
| | | // replace ${self} with the registry url |
|---|
| | | String content = FileUtils.readContent(file, "\n"); |
|---|
| | | content = content.replace("${self}", selfUrl.toString()); |
|---|
| | | FileUtils.writeContent(file, content); |
|---|
| | | } |
|---|
| | | } catch (Exception e) { |
|---|
| | | logger.error(String.format("Failed to retrieve plugins.json from %s", url), e); |
|---|
| | | } |
|---|
| | | return false; |
|---|
| | | } |
|---|
| | | |
|---|
| | | protected List<PluginRegistry> getRegistries() { |
|---|
| | | List<PluginRegistry> list = new ArrayList<PluginRegistry>(); |
|---|
| | | File folder = runtimeManager.getFileOrFolder(Keys.plugins.folder, "${baseFolder}/plugins"); |
|---|
| | | FileFilter jsonFilter = new FileFilter() { |
|---|
| | | @Override |
|---|
| | | public boolean accept(File file) { |
|---|
| | | return !file.isDirectory() && file.getName().toLowerCase().endsWith(".json"); |
|---|
| | | } |
|---|
| | | }; |
|---|
| | | |
|---|
| | | File[] files = folder.listFiles(jsonFilter); |
|---|
| | | if (files == null || files.length == 0) { |
|---|
| | | // automatically retrieve the registry if we don't have a local copy |
|---|
| | | refreshRegistry(true); |
|---|
| | | files = folder.listFiles(jsonFilter); |
|---|
| | | } |
|---|
| | | |
|---|
| | | if (files == null || files.length == 0) { |
|---|
| | | return list; |
|---|
| | | } |
|---|
| | | |
|---|
| | | for (File file : files) { |
|---|
| | | PluginRegistry registry = null; |
|---|
| | | try { |
|---|
| | | String json = FileUtils.readContent(file, "\n"); |
|---|
| | | registry = JsonUtils.fromJsonString(json, PluginRegistry.class); |
|---|
| | | registry.setup(); |
|---|
| | | } catch (Exception e) { |
|---|
| | | logger.error("Failed to deserialize " + file, e); |
|---|
| | | } |
|---|
| | | if (registry != null) { |
|---|
| | | list.add(registry); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return list; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized List<PluginRegistration> getRegisteredPlugins() { |
|---|
| | | List<PluginRegistration> list = new ArrayList<PluginRegistration>(); |
|---|
| | | Map<String, PluginRegistration> map = new TreeMap<String, PluginRegistration>(); |
|---|
| | | for (PluginRegistry registry : getRegistries()) { |
|---|
| | | list.addAll(registry.registrations); |
|---|
| | | for (PluginRegistration reg : list) { |
|---|
| | | reg.installedRelease = null; |
|---|
| | | map.put(reg.id, reg); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | for (PluginWrapper pw : pf4j.getPlugins()) { |
|---|
| | | String id = pw.getDescriptor().getPluginId(); |
|---|
| | | Version pv = pw.getDescriptor().getVersion(); |
|---|
| | | PluginRegistration reg = map.get(id); |
|---|
| | | if (reg != null) { |
|---|
| | | reg.installedRelease = pv.toString(); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return list; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized List<PluginRegistration> getRegisteredPlugins(InstallState state) { |
|---|
| | | List<PluginRegistration> list = getRegisteredPlugins(); |
|---|
| | | Iterator<PluginRegistration> itr = list.iterator(); |
|---|
| | | while (itr.hasNext()) { |
|---|
| | | if (state != itr.next().getInstallState(getSystemVersion())) { |
|---|
| | | itr.remove(); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return list; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized PluginRegistration lookupPlugin(String pluginId) { |
|---|
| | | for (PluginRegistration reg : getRegisteredPlugins()) { |
|---|
| | | if (reg.id.equalsIgnoreCase(pluginId)) { |
|---|
| | | return reg; |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Override |
|---|
| | | public synchronized PluginRelease lookupRelease(String pluginId, String version) { |
|---|
| | | PluginRegistration reg = lookupPlugin(pluginId); |
|---|
| | | if (reg == null) { |
|---|
| | | return null; |
|---|
| | | } |
|---|
| | | |
|---|
| | | PluginRelease pv; |
|---|
| | | if (StringUtils.isEmpty(version)) { |
|---|
| | | pv = reg.getCurrentRelease(getSystemVersion()); |
|---|
| | | } else { |
|---|
| | | pv = reg.getRelease(version); |
|---|
| | | } |
|---|
| | | return pv; |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Downloads a file with optional checksum verification. |
|---|
| | | * |
|---|
| | | * @param url |
|---|
| | | * @param verifyChecksum |
|---|
| | | * @return |
|---|
| | | * @throws IOException |
|---|
| | | */ |
|---|
| | | protected File download(String url, boolean verifyChecksum) throws IOException { |
|---|
| | | File file = downloadFile(url); |
|---|
| | | |
|---|
| | | File sha1File = null; |
|---|
| | | try { |
|---|
| | | sha1File = downloadFile(url + ".sha1"); |
|---|
| | | } catch (IOException e) { |
|---|
| | | } |
|---|
| | | |
|---|
| | | File md5File = null; |
|---|
| | | try { |
|---|
| | | md5File = downloadFile(url + ".md5"); |
|---|
| | | } catch (IOException e) { |
|---|
| | | |
|---|
| | | } |
|---|
| | | |
|---|
| | | if (sha1File == null && md5File == null && verifyChecksum) { |
|---|
| | | throw new IOException("Missing SHA1 and MD5 checksums for " + url); |
|---|
| | | } |
|---|
| | | |
|---|
| | | String expected; |
|---|
| | | MessageDigest md = null; |
|---|
| | | if (sha1File != null && sha1File.exists()) { |
|---|
| | | // prefer SHA1 to MD5 |
|---|
| | | expected = FileUtils.readContent(sha1File, "\n").split(" ")[0].trim(); |
|---|
| | | try { |
|---|
| | | md = MessageDigest.getInstance("SHA-1"); |
|---|
| | | } catch (NoSuchAlgorithmException e) { |
|---|
| | | logger.error(null, e); |
|---|
| | | } |
|---|
| | | } else { |
|---|
| | | expected = FileUtils.readContent(md5File, "\n").split(" ")[0].trim(); |
|---|
| | | try { |
|---|
| | | md = MessageDigest.getInstance("MD5"); |
|---|
| | | } catch (Exception e) { |
|---|
| | | logger.error(null, e); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | // calculate the checksum |
|---|
| | | FileInputStream is = null; |
|---|
| | | try { |
|---|
| | | is = new FileInputStream(file); |
|---|
| | | DigestInputStream dis = new DigestInputStream(is, md); |
|---|
| | | byte [] buffer = new byte[1024]; |
|---|
| | | while ((dis.read(buffer)) > -1) { |
|---|
| | | // read |
|---|
| | | } |
|---|
| | | dis.close(); |
|---|
| | | |
|---|
| | | byte [] digest = md.digest(); |
|---|
| | | String calculated = StringUtils.toHex(digest).trim(); |
|---|
| | | |
|---|
| | | if (!expected.equals(calculated)) { |
|---|
| | | String msg = String.format("Invalid checksum for %s\nAlgorithm: %s\nExpected: %s\nCalculated: %s", |
|---|
| | | file.getAbsolutePath(), |
|---|
| | | md.getAlgorithm(), |
|---|
| | | expected, |
|---|
| | | calculated); |
|---|
| | | file.delete(); |
|---|
| | | throw new IOException(msg); |
|---|
| | | } |
|---|
| | | } finally { |
|---|
| | | if (is != null) { |
|---|
| | | is.close(); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | return file; |
|---|
| | | } |
|---|
| | | |
|---|
| | | /** |
|---|
| | | * Download a file to the plugins folder. |
|---|
| | | * |
|---|
| | | * @param url |
|---|
| | | * @return the downloaded file |
|---|
| | | * @throws IOException |
|---|
| | | */ |
|---|
| | | protected File downloadFile(String url) throws IOException { |
|---|
| | | File pFolder = runtimeManager.getFileOrFolder(Keys.plugins.folder, "${baseFolder}/plugins"); |
|---|
| | | pFolder.mkdirs(); |
|---|
| | | File tmpFile = new File(pFolder, StringUtils.getSHA1(url) + ".tmp"); |
|---|
| | | if (tmpFile.exists()) { |
|---|
| | | tmpFile.delete(); |
|---|
| | | } |
|---|
| | | |
|---|
| | | URL u = new URL(url); |
|---|
| | | final URLConnection conn = getConnection(u); |
|---|
| | | |
|---|
| | | // try to get the server-specified last-modified date of this artifact |
|---|
| | | long lastModified = conn.getHeaderFieldDate("Last-Modified", System.currentTimeMillis()); |
|---|
| | | |
|---|
| | | Files.copy(new InputSupplier<InputStream>() { |
|---|
| | | @Override |
|---|
| | | public InputStream getInput() throws IOException { |
|---|
| | | return new BufferedInputStream(conn.getInputStream()); |
|---|
| | | } |
|---|
| | | }, tmpFile); |
|---|
| | | |
|---|
| | | File destFile = new File(pFolder, StringUtils.getLastPathElement(u.getPath())); |
|---|
| | | if (destFile.exists()) { |
|---|
| | | destFile.delete(); |
|---|
| | | } |
|---|
| | | tmpFile.renameTo(destFile); |
|---|
| | | destFile.setLastModified(lastModified); |
|---|
| | | |
|---|
| | | return destFile; |
|---|
| | | } |
|---|
| | | |
|---|
| | | protected URLConnection getConnection(URL url) throws IOException { |
|---|
| | | java.net.Proxy proxy = getProxy(url); |
|---|
| | | HttpURLConnection conn = (HttpURLConnection) url.openConnection(proxy); |
|---|
| | | if (java.net.Proxy.Type.DIRECT != proxy.type()) { |
|---|
| | | String auth = getProxyAuthorization(url); |
|---|
| | | conn.setRequestProperty("Proxy-Authorization", auth); |
|---|
| | | } |
|---|
| | | |
|---|
| | | String username = null; |
|---|
| | | String password = null; |
|---|
| | | if (!StringUtils.isEmpty(username) && !StringUtils.isEmpty(password)) { |
|---|
| | | // set basic authentication header |
|---|
| | | String auth = Base64.encodeBytes((username + ":" + password).getBytes()); |
|---|
| | | conn.setRequestProperty("Authorization", "Basic " + auth); |
|---|
| | | } |
|---|
| | | |
|---|
| | | // configure timeouts |
|---|
| | | conn.setConnectTimeout(connectTimeout * 1000); |
|---|
| | | conn.setReadTimeout(readTimeout * 1000); |
|---|
| | | |
|---|
| | | switch (conn.getResponseCode()) { |
|---|
| | | case HttpURLConnection.HTTP_MOVED_TEMP: |
|---|
| | | case HttpURLConnection.HTTP_MOVED_PERM: |
|---|
| | | // handle redirects by closing this connection and opening a new |
|---|
| | | // one to the new location of the requested resource |
|---|
| | | String newLocation = conn.getHeaderField("Location"); |
|---|
| | | if (!StringUtils.isEmpty(newLocation)) { |
|---|
| | | logger.info("following redirect to {0}", newLocation); |
|---|
| | | conn.disconnect(); |
|---|
| | | return getConnection(new URL(newLocation)); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | return conn; |
|---|
| | | } |
|---|
| | | |
|---|
| | | protected Proxy getProxy(URL url) { |
|---|
| | | return java.net.Proxy.NO_PROXY; |
|---|
| | | } |
|---|
| | | |
|---|
| | | protected String getProxyAuthorization(URL url) { |
|---|
| | | return ""; |
|---|
| | | } |
|---|
| | | } |
|---|
