Merge commit '087a6e8e7f1b0e63633831948e99ae110b92ae45'

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

diff --git a/src/be/nikiroo/utils/Cache.java b/src/be/nikiroo/utils/Cache.java
index bba88bb4b48f7e970039002393a72a47d50081cf..6233082742606f72538fb5ccb2a3ffd4c64e9136 100644 (file)
--- a/src/be/nikiroo/utils/Cache.java
+++ b/src/be/nikiroo/utils/Cache.java
@@ -1,13 +1,14 @@
 package be.nikiroo.utils;
 
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
 import java.util.Date;
 
+import be.nikiroo.utils.streams.MarkableFileInputStream;
+
 /**
  * A generic cache system, with special support for {@link URL}s.
  * <p>
@@ -47,8 +48,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();
@@ -158,7 +159,16 @@ public class Cache {
         * @return the number of cleaned items
         */
        public int clean(boolean onlyOld) {
-               return clean(onlyOld, dir);
+               long ms = System.currentTimeMillis();
+
+               tracer.trace("Cleaning cache from old files...");
+
+               int num = clean(onlyOld, dir, -1);
+
+               tracer.trace(num + "cache items cleaned in "
+                               + (System.currentTimeMillis() - ms) + " ms");
+
+               return num;
        }
 
        /**
@@ -169,21 +179,31 @@ public class Cache {
         *            resources
         * @param cacheDir
         *            the cache directory to clean
+        * @param limit
+        *            stop after limit files deleted, or -1 for unlimited
         * 
         * @return the number of cleaned items
         */
-       private int clean(boolean onlyOld, File cacheDir) {
+       private int clean(boolean onlyOld, File cacheDir, int limit) {
                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 (limit >= 0 && num >= limit) {
+                                       return num;
+                               }
+
+                               if (file.isDirectory()) {
+                                       num += clean(onlyOld, file, limit);
+                                       file.delete(); // only if empty
+                               } else {
+                                       if (!onlyOld || isOld(file, true)) {
+                                               if (file.delete()) {
+                                                       num++;
+                                               } else {
+                                                       tracer.error("Cannot delete temporary file: "
+                                                                       + file.getAbsolutePath());
+                                               }
                                        }
                                }
                        }
@@ -217,8 +237,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
         */
@@ -243,7 +264,7 @@ public class Cache {
                if (cached.exists() && cached.isFile()
                                && (allowTooOld || !isOld(cached, stable))) {
                        try {
-                               return new MarkableFileInputStream(new FileInputStream(cached));
+                               return new MarkableFileInputStream(cached);
                        } catch (FileNotFoundException e) {
                                return null;
                        }
@@ -260,13 +281,15 @@ public class Cache {
         * @param uniqueID
         *            a unique ID used to locate the cached resource
         * 
+        * @return the number of bytes written
+        * 
         * @throws IOException
         *             in case of I/O error
         */
-       public void save(InputStream in, String uniqueID) throws IOException {
+       public long save(InputStream in, String uniqueID) throws IOException {
                File cached = getCached(uniqueID);
                cached.getParentFile().mkdirs();
-               save(in, cached);
+               return save(in, cached);
        }
 
        /**
@@ -277,27 +300,39 @@ public class Cache {
         * @param url
         *            the {@link URL} used to locate the cached resource
         * 
+        * @return the number of bytes written
+        * 
         * @throws IOException
         *             in case of I/O error
         */
-       public void save(InputStream in, URL url) throws IOException {
+       public long save(InputStream in, URL url) throws IOException {
                File cached = getCached(url);
-               save(in, cached);
+               return 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 number of bytes written
+        * 
         * @throws IOException
         *             in case of I/O error
         */
-       private void save(InputStream in, File cached) throws IOException {
-               IOUtils.write(in, cached);
+       private long save(InputStream in, File cached) throws IOException {
+               // We want to force at least an immediate SAVE/LOAD to work for some
+               // workflows, even if we don't accept cached files (times set to "0"
+               // -- and not "-1" or a positive value)
+               clean(true, dir, 10);
+               cached.getParentFile().mkdirs(); // in case we deleted our own parent
+               long bytes = IOUtils.write(in, cached);
+               return bytes;
        }
 
        /**