/hg/icedtea-web: Changed cache to prevent jar overwriting when u...
asu at icedtea.classpath.org
asu at icedtea.classpath.org
Mon Apr 18 14:36:31 PDT 2011
changeset 211a5e73d119 in /hg/icedtea-web
details: http://icedtea.classpath.org/hg/icedtea-web?cmd=changeset;node=211a5e73d119
author: Andrew Su <asu at redhat.com>
date: Mon Apr 18 17:38:31 2011 -0400
Changed cache to prevent jar overwriting when update happens.
diffstat:
ChangeLog | 42 ++
netx/net/sourceforge/jnlp/cache/CacheEntry.java | 20 +
netx/net/sourceforge/jnlp/cache/CacheLRUWrapper.java | 245 +++++++++++++++++
netx/net/sourceforge/jnlp/cache/CacheUtil.java | 200 ++++++++++++-
netx/net/sourceforge/jnlp/cache/ResourceTracker.java | 133 +++++---
netx/net/sourceforge/jnlp/runtime/JNLPClassLoader.java | 4 +-
netx/net/sourceforge/jnlp/runtime/JNLPRuntime.java | 1 +
netx/net/sourceforge/jnlp/util/FileUtils.java | 42 ++
netx/net/sourceforge/jnlp/util/XDesktopEntry.java | 2 +-
9 files changed, 624 insertions(+), 65 deletions(-)
diffs (truncated from 857 to 500 lines):
diff -r 37f99d9fbdeb -r 211a5e73d119 ChangeLog
--- a/ChangeLog Mon Apr 18 15:13:23 2011 -0400
+++ b/ChangeLog Mon Apr 18 17:38:31 2011 -0400
@@ -1,3 +1,45 @@
+2011-04-18 Andrew Su <asu at redhat.com>
+
+ * netx/net/sourceforge/jnlp/cache/CacheEntry.java:
+ (markForDelete): New method. Adds an entry to info file specifying
+ that this file should be delete.
+ (lock): New method. Locks the info file.
+ (unlock): New method. Unlocks the info file.
+ * netx/net/sourceforge/jnlp/cache/CacheUtil.java:
+ (cacheDir, lruHandler, propertiesLockPool): New private static fields.
+ (clearCache): Changed to use static field.
+ (getCacheFile): Changed to call getCacheFileIfExist and
+ makeNewCacheFile where appropriate.
+ (getCacheFileIfExist): New method. Get the file of requested item.
+ (makeNewCacheFile): New method. Create a new location to store cache
+ file.
+ (pathToURLPath): New method. Convert the file path to the url path.
+ (cleanCache): New method. Search for redundant entries and remove
+ them.
+ (removeUntrackedDirectories): New method. Remove all untracked
+ directories.
+ (lockFile): New method. Locks the given property file.
+ (unlockFile): New method. Unlocks the property file if we locked
+ before.
+ * netx/net/sourceforge/jnlp/cache/CacheLRUWrapper.java: New class.
+ Provides wrappers for handling cache's LRU.
+ * netx/net/sourceforge/jnlp/cache/ResourceTracker.java:
+ (downloadResource): Ensure that we only allow downloading the
+ specified file once.
+ (initializeResource): Added creation of new location to store an
+ updated or new file.
+ * netx/net/sourceforge/jnlp/runtime/JNLPClassLoader.java:
+ (JNLPClassLoader): Reordered the calls since we should check
+ permission after we have the files ready.
+ * netx/net/sourceforge/jnlp/runtime/JNLPRuntime.java:
+ (markNetxRunning): Added call to CacheUtil.cleanCache() when adding
+ shutdown hooks.
+ * netx/net/sourceforge/jnlp/util/FileUtils.java:
+ (getFileLock): New method.
+ * netx/net/sourceforge/jnlp/util/XDesktopEntry.java:
+ (getContentsAsReader): Changed call from using urlToPath to
+ getCacheFile, since the directories are no longer in that location.
+
2011-04-18 Denis Lila <dlila at redhat.com>
* netx/net/sourceforge/jnlp/Launcher.java:
diff -r 37f99d9fbdeb -r 211a5e73d119 netx/net/sourceforge/jnlp/cache/CacheEntry.java
--- a/netx/net/sourceforge/jnlp/cache/CacheEntry.java Mon Apr 18 15:13:23 2011 -0400
+++ b/netx/net/sourceforge/jnlp/cache/CacheEntry.java Mon Apr 18 17:38:31 2011 -0400
@@ -162,4 +162,24 @@
properties.store();
}
+ /**
+ * Mark this entry for deletion at shutdown.
+ */
+ public void markForDelete() { // once marked it should not be unmarked.
+ properties.setProperty("delete", Boolean.toString(true));
+ }
+
+ /**
+ * Lock cache item.
+ */
+ protected void lock() {
+ CacheUtil.lockFile(properties);
+ }
+
+ /**
+ * Unlock cache item.
+ */
+ protected void unlock() {
+ CacheUtil.unlockFile(properties);
+ }
}
diff -r 37f99d9fbdeb -r 211a5e73d119 netx/net/sourceforge/jnlp/cache/CacheLRUWrapper.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/netx/net/sourceforge/jnlp/cache/CacheLRUWrapper.java Mon Apr 18 17:38:31 2011 -0400
@@ -0,0 +1,245 @@
+/* CacheLRUWrapper -- Handle LRU for cache files.
+ Copyright (C) 2011 Red Hat, Inc.
+
+This file is part of IcedTea.
+
+IcedTea is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License as published by
+the Free Software Foundation, version 2.
+
+IcedTea is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with IcedTea; see the file COPYING. If not, write to
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version.
+ */
+package net.sourceforge.jnlp.cache;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.FileLock;
+import java.nio.channels.OverlappingFileLockException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map.Entry;
+
+import net.sourceforge.jnlp.config.DeploymentConfiguration;
+import net.sourceforge.jnlp.runtime.JNLPRuntime;
+import net.sourceforge.jnlp.util.FileUtils;
+import net.sourceforge.jnlp.util.PropertiesFile;
+
+/**
+ * This class helps maintain the ordering of most recently use items across
+ * multiple jvm instances.
+ *
+ * @author Andrew Su (asu at redhat.com, andrew.su at utoronto.ca)
+ *
+ */
+enum CacheLRUWrapper {
+ INSTANCE;
+
+ private int lockCount = 0;
+
+ /* lock for the file RecentlyUsed */
+ private FileLock fl = null;
+
+ /* location of cache directory */
+ private final String cacheDir = new File(JNLPRuntime.getConfiguration()
+ .getProperty(DeploymentConfiguration.KEY_USER_CACHE_DIR)).getPath();
+
+ /*
+ * back-end of how LRU is implemented This file is to keep track of the most
+ * recently used items. The items are to be kept with key = (current time
+ * accessed) followed by folder of item. value = path to file.
+ */
+ private PropertiesFile cacheOrder = new PropertiesFile(
+ new File(cacheDir + File.separator + "recently_used"));
+
+ /**
+ * Returns an instance of the policy.
+ *
+ * @param propertiesFile
+ * @return
+ */
+ public static CacheLRUWrapper getInstance() {
+ return INSTANCE;
+ }
+
+ /**
+ * Update map for keeping track of recently used items.
+ */
+ public synchronized void load() {
+ cacheOrder.load();
+ }
+
+ /**
+ * Write file to disk.
+ */
+ public synchronized void store() {
+ cacheOrder.store();
+ }
+
+ /**
+ * This adds a new entry to file.
+ *
+ * @param key key we want path to be associated with.
+ * @param path path to cache item.
+ * @return true if we successfully added to map, false otherwise.
+ */
+ public synchronized boolean addEntry(String key, String path) {
+ if (cacheOrder.containsKey(key)) return false;
+ cacheOrder.setProperty(key, path);
+ return true;
+ }
+
+ /**
+ * This removed an entry from our map.
+ *
+ * @param key key we want to remove.
+ * @return true if we successfully removed key from map, false otherwise.
+ */
+ public synchronized boolean removeEntry(String key) {
+ if (!cacheOrder.containsKey(key)) return false;
+ cacheOrder.remove(key);
+ return true;
+ }
+
+ private String getIdForCacheFolder(String folder) {
+ int len = cacheDir.length();
+ int index = folder.indexOf(File.separatorChar, len + 1);
+ return folder.substring(len + 1, index);
+ }
+
+ /**
+ * This updates the given key to reflect it was recently accessed.
+ *
+ * @param oldKey Key we wish to update.
+ * @return true if we successfully updated value, false otherwise.
+ */
+ public synchronized boolean updateEntry(String oldKey) {
+ if (!cacheOrder.containsKey(oldKey)) return false;
+ String value = cacheOrder.getProperty(oldKey);
+ String folder = getIdForCacheFolder(value);
+
+ cacheOrder.remove(oldKey);
+ cacheOrder.setProperty(Long.toString(System.currentTimeMillis()) + "," + folder, value);
+ return true;
+ }
+
+ /**
+ * Return a copy of the keys available.
+ *
+ * @return List of Strings sorted by ascending order.
+ */
+ public synchronized List<Entry<String, String>> getLRUSortedEntries() {
+ ArrayList<Entry<String, String>> entries = new ArrayList(cacheOrder.entrySet());
+ // sort by keys in descending order.
+ Collections.sort(entries, new Comparator<Entry<String, String>>() {
+ @Override
+ public int compare(Entry<String, String> e1, Entry<String, String> e2) {
+ try {
+ Long t1 = Long.parseLong(e1.getKey().split(",")[0]);
+ Long t2 = Long.parseLong(e2.getKey().split(",")[0]);
+
+ int c = t1.compareTo(t2);
+ return c < 0 ? 1 : (c > 0 ? -1 : 0);
+ } catch (NumberFormatException e) {
+ // Perhaps an error is too harsh. Maybe just somehow turn
+ // caching off if this is the case.
+ throw new InternalError("Corrupt LRU file entries");
+ }
+ }
+ });
+ return entries;
+ }
+
+ /**
+ * Lock the file to have exclusive access.
+ */
+ public synchronized void lock() {
+ try {
+ File f = cacheOrder.getStoreFile();
+ if (!f.exists()) {
+ FileUtils.createParentDir(f);
+ FileUtils.createRestrictedFile(f, true);
+ }
+ fl = FileUtils.getFileLock(f.getPath(), false, true);
+ } catch (OverlappingFileLockException e) { // if overlap we just increase the count.
+ } catch (Exception e) { // We didn't get a lock..
+ e.printStackTrace();
+ }
+ if (fl != null) lockCount++;
+ }
+
+ /**
+ * Unlock the file.
+ */
+ public synchronized void unlock() {
+ if (fl != null) {
+ lockCount--;
+ try {
+ if (lockCount == 0) {
+ fl.release();
+ fl.channel().close();
+ fl = null;
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ /**
+ * Return the value of given key.
+ *
+ * @param key
+ * @return value of given key, null otherwise.
+ */
+ public synchronized String getValue(String key) {
+ return cacheOrder.getProperty(key);
+ }
+
+ /**
+ * Test if we the key provided is in use.
+ *
+ * @param key key to be tested.
+ * @return true if the key is in use.
+ */
+ public synchronized boolean contains(String key) {
+ return cacheOrder.contains(key);
+ }
+
+ /**
+ * Generate a key given the path to file. May or may not generate the same
+ * key given same path.
+ *
+ * @param path Path to generate a key with.
+ * @return String representing the a key.
+ */
+ public String generateKey(String path) {
+ return System.currentTimeMillis() + "," + getIdForCacheFolder(path);
+ }
+}
diff -r 37f99d9fbdeb -r 211a5e73d119 netx/net/sourceforge/jnlp/cache/CacheUtil.java
--- a/netx/net/sourceforge/jnlp/cache/CacheUtil.java Mon Apr 18 15:13:23 2011 -0400
+++ b/netx/net/sourceforge/jnlp/cache/CacheUtil.java Mon Apr 18 17:38:31 2011 -0400
@@ -21,7 +21,14 @@
import java.io.*;
import java.net.*;
import java.nio.channels.FileChannel;
-import java.util.*;
+import java.nio.channels.FileLock;
+import java.nio.channels.OverlappingFileLockException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
import java.security.*;
import javax.jnlp.*;
@@ -29,6 +36,7 @@
import net.sourceforge.jnlp.config.DeploymentConfiguration;
import net.sourceforge.jnlp.runtime.*;
import net.sourceforge.jnlp.util.FileUtils;
+import net.sourceforge.jnlp.util.PropertiesFile;
/**
* Provides static methods to interact with the cache, download
@@ -39,6 +47,11 @@
*/
public class CacheUtil {
+ private static final String cacheDir = new File(JNLPRuntime.getConfiguration()
+ .getProperty(DeploymentConfiguration.KEY_USER_CACHE_DIR)).getPath(); // Do this with file to standardize it.
+ private static final CacheLRUWrapper lruHandler = CacheLRUWrapper.getInstance();
+ private static final HashMap<String, FileLock> propertiesLockPool = new HashMap<String, FileLock>();
+
/**
* Compares a URL using string compare of its protocol, host,
* port, path, query, and anchor. This method avoids the host
@@ -138,8 +151,7 @@
return;
}
- File cacheDir = new File(JNLPRuntime.getConfiguration()
- .getProperty(DeploymentConfiguration.KEY_USER_CACHE_DIR));
+ File cacheDir = new File(CacheUtil.cacheDir);
if (!(cacheDir.isDirectory())) {
return;
}
@@ -284,18 +296,95 @@
if (!isCacheable(source, version))
throw new IllegalArgumentException(R("CNotCacheable", source));
- try {
- String cacheDir = JNLPRuntime.getConfiguration()
- .getProperty(DeploymentConfiguration.KEY_USER_CACHE_DIR);
- File localFile = urlToPath(source, cacheDir);
- FileUtils.createParentDir(localFile);
+ File cacheFile = null;
+ synchronized (lruHandler) {
+ lruHandler.lock();
- return localFile;
- } catch (Exception ex) {
- if (JNLPRuntime.isDebug())
- ex.printStackTrace();
+ // We need to reload the cacheOrder file each time
+ // since another plugin/javaws instance may have updated it.
+ lruHandler.load();
+ cacheFile = getCacheFileIfExist(urlToPath(source, ""));
+ if (cacheFile == null) { // We did not find a copy of it.
+ cacheFile = makeNewCacheFile(source, version);
+ }
+ lruHandler.unlock();
+ }
+ return cacheFile;
+ }
- return null;
+ /**
+ * This will return a File pointing to the location of cache item.
+ *
+ * @param urlPath Path of cache item within cache directory.
+ * @return File if we have searched before, null otherwise.
+ */
+ private static File getCacheFileIfExist(File urlPath) {
+ synchronized (lruHandler) {
+ File cacheFile = null;
+ List<Entry<String, String>> entries = lruHandler.getLRUSortedEntries();
+ // Start searching from the most recent to least recent.
+ for (Entry<String, String> e : entries) {
+ final String key = e.getKey();
+ final String path = e.getValue();
+
+ if (path != null) {
+ if (pathToURLPath(path).equals(urlPath.getPath())) { // Match found.
+ cacheFile = new File(path);
+ lruHandler.updateEntry(key);
+ break; // Stop searching since we got newest one already.
+ }
+ }
+ }
+ return cacheFile;
+ }
+ }
+
+ /**
+ * Get the path to file minus the cache directory and indexed folder.
+ */
+ private static String pathToURLPath(String path) {
+ int len = cacheDir.length();
+ int index = path.indexOf(File.separatorChar, len + 1);
+ return path.substring(index);
+ }
+
+ /**
+ * This will create a new entry for the cache item. It is however not
+ * initialized but any future calls to getCacheFile with the source and
+ * version given to here, will cause it to return this item.
+ *
+ * @param source the source URL
+ * @param version the version id of the local file
+ * @return the file location in the cache.
+ */
+ public static File makeNewCacheFile(URL source, Version version) {
+ synchronized (lruHandler) {
+ lruHandler.lock();
+ lruHandler.load();
+
+ File cacheFile = null;
+ for (long i = 0; i < Long.MAX_VALUE; i++) {
+ String path = cacheDir + File.separator + i;
+ File cDir = new File(path);
+ if (!cDir.exists()) {
+ // We can use this directory.
+ try {
+ cacheFile = urlToPath(source, path);
+ FileUtils.createParentDir(cacheFile);
+ File pf = new File(cacheFile.getPath() + ".info");
+ FileUtils.createRestrictedFile(pf, true); // Create the info file for marking later.
+ lruHandler.addEntry(lruHandler.generateKey(cacheFile.getPath()), cacheFile.getPath());
+ } catch (IOException ioe) {
+ ioe.printStackTrace();
+ }
+
+ break;
+ }
+ }
+
+ lruHandler.store();
+ lruHandler.unlock();
+ return cacheFile;
}
}
@@ -436,4 +525,89 @@
}
}
+ /**
+ * This will remove all old cache items.
+ */
+ public static void cleanCache() {
+ if (okToClearCache()) {
+ // First we want to figure out which stuff we need to delete.
+ HashSet<String> keep = new HashSet<String>();
+ lruHandler.load();
+
+ for (Entry<String, String> e : lruHandler.getLRUSortedEntries()) {
+ // Check if the item is contained in cacheOrder.
+ final String key = e.getKey();
+ final String value = e.getValue();
+
+ if (value != null) {
More information about the distro-pkg-dev
mailing list