Improve Downloader and Cache:

[nikiroo-utils.git] / src / be / nikiroo / utils / Cache.java

diff --git a/src/be/nikiroo/utils/Cache.java b/src/be/nikiroo/utils/Cache.java
index 393f634dc5a2b011f88b5e1103ab26d6293e8641..4750ef844f1e6593ab1f90ebd76273ddaee77497 100644 (file)
--- a/src/be/nikiroo/utils/Cache.java
+++ b/src/be/nikiroo/utils/Cache.java
@@ -21,6 +21,12 @@ public class Cache {
        private long tooOldStable;
        private TraceHandler tracer = new TraceHandler();
 
+       /**
+        * Only for inheritance.
+        */
+       protected Cache() {
+       }
+
        /**
         * Create a new {@link Cache} object.
         * 
@@ -41,8 +47,8 @@ public class Cache {
        public Cache(File dir, int hoursChanging, int hoursStable)
                        throws IOException {
                this.dir = dir;
-               this.tooOldChanging = 1000 * 60 * 60 * hoursChanging;
-               this.tooOldStable = 1000 * 60 * 60 * hoursStable;
+               this.tooOldChanging = 1000L * 60 * 60 * hoursChanging;
+               this.tooOldStable = 1000L * 60 * 60 * hoursStable;
 
                if (dir != null && !dir.exists()) {
                        dir.mkdirs();
@@ -70,9 +76,31 @@ public class Cache {
         *            the new traces handler
         */
        public void setTraceHandler(TraceHandler tracer) {
+               if (tracer == null) {
+                       tracer = new TraceHandler(false, false, false);
+               }
+
                this.tracer = tracer;
        }
 
+       /**
+        * Check the resource to see if it is in the cache.
+        * 
+        * @param uniqueID
+        *            the resource to check
+        * @param allowTooOld
+        *            allow files even if they are considered too old
+        * @param stable
+        *            a stable file (that dones't change too often) -- parameter
+        *            used to check if the file is too old to keep or not
+        * 
+        * @return TRUE if it is
+        * 
+        */
+       public boolean check(String uniqueID, boolean allowTooOld, boolean stable) {
+               return check(getCached(uniqueID), allowTooOld, stable);
+       }
+
        /**
         * Check the resource to see if it is in the cache.
         * 
@@ -88,9 +116,31 @@ public class Cache {
         * 
         */
        public boolean check(URL url, boolean allowTooOld, boolean stable) {
-               File file = getCached(url);
-               if (file.exists()) {
-                       if (allowTooOld || !isOld(file, stable)) {
+               return check(getCached(url), allowTooOld, stable);
+       }
+
+       /**
+        * Check the resource to see if it is in the cache.
+        * 
+        * @param cached
+        *            the resource to check
+        * @param allowTooOld
+        *            allow files even if they are considered too old
+        * @param stable
+        *            a stable file (that dones't change too often) -- parameter
+        *            used to check if the file is too old to keep or not
+        * 
+        * @return TRUE if it is
+        * 
+        */
+       private boolean check(File cached, boolean allowTooOld, boolean stable) {
+               if (cached.exists() && cached.isFile()) {
+                       if (!allowTooOld && isOld(cached, stable)) {
+                               if (!cached.delete()) {
+                                       tracer.error("Cannot delete temporary file: "
+                                                       + cached.getAbsolutePath());
+                               }
+                       } else {
                                return true;
                        }
                }
@@ -124,16 +174,19 @@ public class Cache {
         */
        private int clean(boolean onlyOld, File cacheDir) {
                int num = 0;
-               for (File file : cacheDir.listFiles()) {
-                       if (file.isDirectory()) {
-                               num += clean(onlyOld, file);
-                       } else {
-                               if (!onlyOld || isOld(file, true)) {
-                                       if (file.delete()) {
-                                               num++;
-                                       } else {
-                                               tracer.error("Cannot delete temporary file: "
-                                                               + file.getAbsolutePath());
+               File[] files = cacheDir.listFiles();
+               if (files != null) {
+                       for (File file : files) {
+                               if (file.isDirectory()) {
+                                       num += clean(onlyOld, file);
+                               } else {
+                                       if (!onlyOld || isOld(file, true)) {
+                                               if (file.delete()) {
+                                                       num++;
+                                               } else {
+                                                       tracer.error("Cannot delete temporary file: "
+                                                                       + file.getAbsolutePath());
+                                               }
                                        }
                                }
                        }
@@ -167,8 +220,9 @@ public class Cache {
         * @param allowTooOld
         *            allow files even if they are considered too old
         * @param stable
-        *            a stable file (that dones't change too often) -- parameter
-        *            used to check if the file is too old to keep or not
+        *            a stable file (that doesn't change too often) -- parameter
+        *            used to check if the file is too old to keep or not in the
+        *            cache
         * 
         * @return the opened resource if found, NULL if not
         */
@@ -190,7 +244,8 @@ public class Cache {
         * @return the opened resource if found, NULL if not
         */
        private InputStream load(File cached, boolean allowTooOld, boolean stable) {
-               if (cached.exists() && (allowTooOld || !isOld(cached, stable))) {
+               if (cached.exists() && cached.isFile()
+                               && (allowTooOld || !isOld(cached, stable))) {
                        try {
                                return new MarkableFileInputStream(new FileInputStream(cached));
                        } catch (FileNotFoundException e) {
@@ -209,15 +264,13 @@ public class Cache {
         * @param uniqueID
         *            a unique ID used to locate the cached resource
         * 
-        * @return the resulting {@link File}
-        * 
         * @throws IOException
         *             in case of I/O error
         */
-       public File save(InputStream in, String uniqueID) throws IOException {
+       public void save(InputStream in, String uniqueID) throws IOException {
                File cached = getCached(uniqueID);
                cached.getParentFile().mkdirs();
-               return save(in, cached);
+               save(in, cached);
        }
 
        /**
@@ -228,32 +281,30 @@ public class Cache {
         * @param url
         *            the {@link URL} used to locate the cached resource
         * 
-        * @return the actual cache file
-        * 
         * @throws IOException
         *             in case of I/O error
         */
-       public File save(InputStream in, URL url) throws IOException {
+       public void save(InputStream in, URL url) throws IOException {
                File cached = getCached(url);
-               return save(in, cached);
+               save(in, cached);
        }
 
        /**
         * Save the given resource to the cache.
+        * <p>
+        * Will also clean the {@link Cache} from old files.
         * 
         * @param in
         *            the input data
         * @param cached
         *            the cached {@link File} to save to
         * 
-        * @return the actual cache file
-        * 
         * @throws IOException
         *             in case of I/O error
         */
-       private File save(InputStream in, File cached) throws IOException {
+       private void save(InputStream in, File cached) throws IOException {
+               clean(true);
                IOUtils.write(in, cached);
-               return cached;
        }
 
        /**