X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Ffanfix%2Flibrary%2FCacheLibrary.java;h=e184c1bd6555e7d79547ab61ab774d92e5b608ff;hb=cfdaf6052ddc5ca44cf19f1f6d9f154cc8443024;hp=d653332a73673aaff0bbce6b0128cb901c15b94b;hpb=e06632eecd6d4b194c3dbe6322097ee61457ec33;p=nikiroo-utils.git diff --git a/src/be/nikiroo/fanfix/library/CacheLibrary.java b/src/be/nikiroo/fanfix/library/CacheLibrary.java index d653332..e184c1b 100644 --- a/src/be/nikiroo/fanfix/library/CacheLibrary.java +++ b/src/be/nikiroo/fanfix/library/CacheLibrary.java @@ -1,14 +1,19 @@ package be.nikiroo.fanfix.library; -import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; +import java.net.URL; +import java.util.ArrayList; import java.util.List; +import java.util.TreeSet; import be.nikiroo.fanfix.Instance; import be.nikiroo.fanfix.bundles.UiConfig; +import be.nikiroo.fanfix.bundles.UiConfigBundle; import be.nikiroo.fanfix.data.MetaData; import be.nikiroo.fanfix.data.Story; +import be.nikiroo.fanfix.output.BasicOutput.OutputType; +import be.nikiroo.utils.Image; import be.nikiroo.utils.Progress; /** @@ -17,7 +22,10 @@ import be.nikiroo.utils.Progress; * @author niki */ public class CacheLibrary extends BasicLibrary { - private List metas; + private List metasReal; + private List metasMixed; + private Object metasLock = new Object(); + private BasicLibrary lib; private LocalLibrary cacheLib; @@ -31,12 +39,15 @@ public class CacheLibrary extends BasicLibrary { * the cache directory where to save the files to disk * @param lib * the original library to wrap + * @param config + * the configuration used to know which kind of default + * {@link OutputType} to use for images and non-images stories */ - public CacheLibrary(File cacheDir, BasicLibrary lib) { - this.cacheLib = new LocalLibrary(cacheDir, Instance.getUiConfig() - .getString(UiConfig.GUI_NON_IMAGES_DOCUMENT_TYPE), Instance - .getUiConfig().getString(UiConfig.GUI_IMAGES_DOCUMENT_TYPE), - true); + public CacheLibrary(File cacheDir, BasicLibrary lib, + UiConfigBundle config) { + this.cacheLib = new LocalLibrary(cacheDir, // + config.getString(UiConfig.GUI_NON_IMAGES_DOCUMENT_TYPE), + config.getString(UiConfig.GUI_IMAGES_DOCUMENT_TYPE), true); this.lib = lib; } @@ -46,47 +57,97 @@ public class CacheLibrary extends BasicLibrary { } @Override - protected List getMetas(Progress pg) { + public Status getStatus() { + return lib.getStatus(); + } + + @Override + protected List getMetas(Progress pg) throws IOException { if (pg == null) { pg = new Progress(); } - if (metas == null) { - metas = lib.getMetas(pg); + List copy; + synchronized (metasLock) { + // We make sure that cached metas have precedence + if (metasMixed == null) { + if (metasReal == null) { + metasReal = lib.getMetas(pg); + } + + metasMixed = new ArrayList(); + TreeSet cachedLuids = new TreeSet(); + for (MetaData cachedMeta : cacheLib.getMetas(null)) { + metasMixed.add(cachedMeta); + cachedLuids.add(cachedMeta.getLuid()); + } + for (MetaData realMeta : metasReal) { + if (!cachedLuids.contains(realMeta.getLuid())) { + metasMixed.add(realMeta); + } + } + } + + copy = new ArrayList(metasMixed); } pg.done(); - return metas; + return copy; } @Override - public synchronized File getFile(final String luid, Progress pg) { + public synchronized Story getStory(String luid, MetaData meta, Progress pg) + throws IOException { if (pg == null) { pg = new Progress(); } Progress pgImport = new Progress(); Progress pgGet = new Progress(); - Progress pgRecall = new Progress(); - pg.setMinMax(0, 5); + pg.setMinMax(0, 4); pg.addProgress(pgImport, 3); pg.addProgress(pgGet, 1); - pg.addProgress(pgRecall, 1); if (!isCached(luid)) { try { cacheLib.imprt(lib, luid, pgImport); + updateMetaCache(metasMixed, cacheLib.getInfo(luid)); pgImport.done(); - clearCache(); } catch (IOException e) { - Instance.syserr(e); + Instance.getInstance().getTraceHandler().error(e); } pgImport.done(); pgGet.done(); } + String type = cacheLib.getOutputType(meta.isImageDocument()); + MetaData cachedMeta = meta.clone(); + cachedMeta.setType(type); + + return cacheLib.getStory(luid, cachedMeta, pg); + } + + @Override + public synchronized File getFile(final String luid, Progress pg) + throws IOException { + if (pg == null) { + pg = new Progress(); + } + + Progress pgGet = new Progress(); + Progress pgRecall = new Progress(); + + pg.setMinMax(0, 5); + pg.addProgress(pgGet, 4); + pg.addProgress(pgRecall, 1); + + if (!isCached(luid)) { + getStory(luid, pgGet); + pgGet.done(); + } + File file = cacheLib.getFile(luid, pgRecall); pgRecall.done(); @@ -95,7 +156,7 @@ public class CacheLibrary extends BasicLibrary { } @Override - public BufferedImage getCover(final String luid) { + public Image getCover(final String luid) throws IOException { if (isCached(luid)) { return cacheLib.getCover(luid); } @@ -105,29 +166,165 @@ public class CacheLibrary extends BasicLibrary { } @Override - public BufferedImage getSourceCover(String source) { - // no cache for the source cover + public Image getSourceCover(String source) throws IOException { + Image custom = getCustomSourceCover(source); + if (custom != null) { + return custom; + } + + Image cached = cacheLib.getSourceCover(source); + if (cached != null) { + return cached; + } + return lib.getSourceCover(source); } @Override - public void setSourceCover(String source, String luid) { + public Image getAuthorCover(String author) throws IOException { + Image custom = getCustomAuthorCover(author); + if (custom != null) { + return custom; + } + + Image cached = cacheLib.getAuthorCover(author); + if (cached != null) { + return cached; + } + + return lib.getAuthorCover(author); + } + + @Override + public Image getCustomSourceCover(String source) throws IOException { + Image custom = cacheLib.getCustomSourceCover(source); + if (custom == null) { + custom = lib.getCustomSourceCover(source); + if (custom != null) { + cacheLib.setSourceCover(source, custom); + } + } + + return custom; + } + + @Override + public Image getCustomAuthorCover(String author) throws IOException { + Image custom = cacheLib.getCustomAuthorCover(author); + if (custom == null) { + custom = lib.getCustomAuthorCover(author); + if (custom != null) { + cacheLib.setAuthorCover(author, custom); + } + } + + return custom; + } + + @Override + public void setSourceCover(String source, String luid) throws IOException { lib.setSourceCover(source, luid); - cacheLib.setSourceCover(source, getSourceCover(source)); + cacheLib.setSourceCover(source, getCover(luid)); + } + + @Override + public void setAuthorCover(String author, String luid) throws IOException { + lib.setAuthorCover(author, luid); + cacheLib.setAuthorCover(author, getCover(luid)); + } + + /** + * Invalidate the {@link Story} cache (when the content has changed, but we + * already have it) with the new given meta. + *

+ * Make sure to always use {@link MetaData} from the cached library in + * priority, here. + * + * @param meta + * the {@link Story} to clear from the cache + * + * @throws IOException + * in case of IOException + */ + @Override + @Deprecated + protected void updateInfo(MetaData meta) throws IOException { + throw new IOException( + "This method is not supported in a CacheLibrary, please use updateMetaCache"); + } + + // relplace the meta in Metas by Meta, add it if needed + // return TRUE = added + private boolean updateMetaCache(List metas, MetaData meta) { + if (meta != null && metas != null) { + synchronized (metasLock) { + boolean changed = false; + for (int i = 0; i < metas.size(); i++) { + if (metas.get(i).getLuid().equals(meta.getLuid())) { + metas.set(i, meta); + changed = true; + } + } + + if (!changed) { + metas.add(meta); + return true; + } + } + } + + return false; } @Override - protected void clearCache() { - metas = null; - cacheLib.clearCache(); - lib.clearCache(); + protected void invalidateInfo(String luid) { + if (luid == null) { + synchronized (metasLock) { + metasReal = null; + metasMixed = null; + } + } else { + invalidateInfo(metasReal, luid); + invalidateInfo(metasMixed, luid); + } + + cacheLib.invalidateInfo(luid); + lib.invalidateInfo(luid); + } + + // luid cannot be null + private void invalidateInfo(List metas, String luid) { + if (metas != null) { + synchronized (metasLock) { + for (int i = 0; i < metas.size(); i++) { + if (metas.get(i).getLuid().equals(luid)) { + metas.remove(i--); + } + } + } + } } @Override public synchronized Story save(Story story, String luid, Progress pg) throws IOException { - story = lib.save(story, luid, pg); - clearCache(); + Progress pgLib = new Progress(); + Progress pgCacheLib = new Progress(); + + if (pg == null) { + pg = new Progress(); + } + + pg.setMinMax(0, 2); + pg.addProgress(pgLib, 1); + pg.addProgress(pgCacheLib, 1); + + story = lib.save(story, luid, pgLib); + updateMetaCache(metasReal, story.getMeta()); + + story = cacheLib.save(story, story.getMeta().getLuid(), pgCacheLib); + updateMetaCache(metasMixed, story.getMeta()); + return story; } @@ -137,12 +334,13 @@ public class CacheLibrary extends BasicLibrary { cacheLib.delete(luid); } lib.delete(luid); - clearCache(); + + invalidateInfo(luid); } @Override - public synchronized void changeSource(String luid, String newSource, - Progress pg) throws IOException { + protected synchronized void changeSTA(String luid, String newSource, + String newTitle, String newAuthor, Progress pg) throws IOException { if (pg == null) { pg = new Progress(); } @@ -153,50 +351,75 @@ public class CacheLibrary extends BasicLibrary { pg.addProgress(pgCache, 1); pg.addProgress(pgOrig, 1); + MetaData meta = getInfo(luid); + if (meta == null) { + throw new IOException("Story not found: " + luid); + } + if (isCached(luid)) { - cacheLib.changeSource(luid, newSource, pgCache); + cacheLib.changeSTA(luid, newSource, newTitle, newAuthor, pgCache); } pgCache.done(); - lib.changeSource(luid, newSource, pgOrig); + + lib.changeSTA(luid, newSource, newTitle, newAuthor, pgOrig); pgOrig.done(); + meta.setSource(newSource); + meta.setTitle(newTitle); + meta.setAuthor(newAuthor); pg.done(); + + if (isCached(luid)) { + updateMetaCache(metasMixed, meta); + updateMetaCache(metasReal, lib.getInfo(luid)); + } else { + updateMetaCache(metasReal, meta); + } } - /** - * Check if the {@link Story} denoted by this Library UID is present in the - * cache. - * - * @param luid - * the Library UID - * - * @return TRUE if it is - */ + @Override public boolean isCached(String luid) { - return cacheLib.getInfo(luid) != null; + try { + return cacheLib.getInfo(luid) != null; + } catch (IOException e) { + return false; + } } - /** - * Clear the {@link Story} from the cache. - * - * @param luid - * the story to clear - * - * @throws IOException - * in case of I/O error - */ + @Override public void clearFromCache(String luid) throws IOException { if (isCached(luid)) { cacheLib.delete(luid); - clearCache(); } } + @Override + public MetaData imprt(URL url, Progress pg) throws IOException { + if (pg == null) { + pg = new Progress(); + } + + Progress pgImprt = new Progress(); + Progress pgCache = new Progress(); + pg.setMinMax(0, 10); + pg.addProgress(pgImprt, 7); + pg.addProgress(pgCache, 3); + + MetaData meta = lib.imprt(url, pgImprt); + updateMetaCache(metasReal, meta); + metasMixed = null; + + clearFromCache(meta.getLuid()); + + pg.done(); + return meta; + } + // All the following methods are only used by Save and Delete in // BasicLibrary: @Override - protected int getNextId() { + protected String getNextId() { throw new java.lang.InternalError("Should not have been called"); }