import be.nikiroo.fanfix.bundles.ConfigBundle;
import be.nikiroo.fanfix.bundles.StringId;
import be.nikiroo.fanfix.bundles.StringIdBundle;
+import be.nikiroo.fanfix.bundles.StringIdGuiBundle;
import be.nikiroo.fanfix.bundles.UiConfig;
import be.nikiroo.fanfix.bundles.UiConfigBundle;
import be.nikiroo.fanfix.library.BasicLibrary;
+import be.nikiroo.fanfix.library.CacheLibrary;
import be.nikiroo.fanfix.library.LocalLibrary;
import be.nikiroo.fanfix.library.RemoteLibrary;
+import be.nikiroo.fanfix.library.WebLibrary;
import be.nikiroo.utils.Cache;
import be.nikiroo.utils.IOUtils;
+import be.nikiroo.utils.Image;
+import be.nikiroo.utils.Proxy;
+import be.nikiroo.utils.TempFiles;
import be.nikiroo.utils.TraceHandler;
import be.nikiroo.utils.resources.Bundles;
* @author niki
*/
public class Instance {
- private static ConfigBundle config;
- private static UiConfigBundle uiconfig;
- private static StringIdBundle trans;
- private static DataLoader cache;
- private static BasicLibrary lib;
- private static File coverDir;
- private static File readerTmp;
- private static File remoteDir;
- private static String configDir;
- private static TraceHandler tracer;
-
- static {
- // Before we can configure it:
- tracer = new TraceHandler(true, checkEnv("DEBUG"), false);
+ static private Instance instance;
+ static private Object instancelock = new Object();
+
+ private ConfigBundle config;
+ private UiConfigBundle uiconfig;
+ private StringIdBundle trans;
+ private DataLoader cache;
+ private StringIdGuiBundle transGui;
+ private BasicLibrary lib;
+ private File coverDir;
+ private File readerTmp;
+ private File remoteDir;
+ private String configDir;
+ private TraceHandler tracer;
+ private TempFiles tempFiles;
- // Most of the rest is dependent upon this:
- config = new ConfigBundle();
+ /**
+ * Initialise the instance -- if already initialised, nothing will happen.
+ * <p>
+ * Before calling this method, you may call
+ * {@link Bundles#setDirectory(String)} if wanted.
+ * <p>
+ * Note that this method will honour some environment variables, the 3 most
+ * important ones probably being:
+ * <ul>
+ * <li><tt>DEBUG</tt>: will enable DEBUG output if set to 1 (or Y or TRUE or
+ * ON, case insensitive)</li>
+ * <li><tt>CONFIG_DIR</tt>: will use this directory as configuration
+ * directory (supports $HOME notation, defaults to $HOME/.fanfix</li>
+ * <li><tt>BOOKS_DIR</tt>: will use this directory as library directory
+ * (supports $HOME notation, defaults to $HOME/Books</li>
+ * </ul>
+ */
+ static public void init() {
+ init(false);
+ }
- configDir = System.getProperty("CONFIG_DIR");
- if (configDir == null) {
- configDir = System.getenv("CONFIG_DIR");
+ /**
+ * Initialise the instance -- if already initialised, nothing will happen
+ * unless you pass TRUE to <tt>force</tt>.
+ * <p>
+ * Before calling this method, you may call
+ * {@link Bundles#setDirectory(String)} if wanted.
+ * <p>
+ * Note: forcing the initialisation can be dangerous, so make sure to only
+ * make it under controlled circumstances -- for instance, at the start of
+ * the program, you could call {@link Instance#init()}, change some settings
+ * because you want to force those settings (it will also forbid users to
+ * change them!) and then call {@link Instance#init(boolean)} with
+ * <tt>force</tt> set to TRUE.
+ *
+ * @param force
+ * force the initialisation even if already initialised
+ */
+ static public void init(boolean force) {
+ synchronized (instancelock) {
+ if (instance == null || force) {
+ instance = new Instance();
+ }
}
- if (configDir == null) {
- configDir = new File(System.getProperty("user.home"), ".fanfix")
- .getPath();
- }
+ }
- if (!new File(configDir).exists()) {
- new File(configDir).mkdirs();
- } else {
- Bundles.setDirectory(configDir);
- }
+ /**
+ * Force-initialise the {@link Instance} to a known value.
+ * <p>
+ * Usually for DEBUG/Test purposes.
+ *
+ * @param instance
+ * the actual Instance to use
+ */
+ static public void init(Instance instance) {
+ Instance.instance = instance;
+ }
- try {
- config = new ConfigBundle();
- config.updateFile(configDir);
- } catch (IOException e) {
- tracer.error(e);
- }
- try {
- uiconfig = new UiConfigBundle();
- uiconfig.updateFile(configDir);
- } catch (IOException e) {
- tracer.error(e);
- }
+ /**
+ * The (mostly unique) instance of this {@link Instance}.
+ *
+ * @return the (mostly unique) instance
+ */
+ public static Instance getInstance() {
+ return instance;
+ }
- // No updateFile for this one! (we do not want the user to have custom
- // translations that won't accept updates from newer versions)
- trans = new StringIdBundle(getLang());
+ /**
+ * Actually initialise the instance.
+ * <p>
+ * Before calling this method, you may call
+ * {@link Bundles#setDirectory(String)} if wanted.
+ */
+ protected Instance() {
+ // Before we can configure it:
+ Boolean debug = checkEnv("DEBUG");
+ boolean trace = debug != null && debug;
+ tracer = new TraceHandler(true, trace, trace);
- // Fix an old bug (we used to store custom translation files by
- // default):
- if (trans.getString(StringId.INPUT_DESC_CBZ) == null) {
- // TODO: create the deleteFile method
- // trans.deleteFile(configDir);
+ // config dir:
+ configDir = getConfigDir();
+ if (!new File(configDir).exists()) {
+ new File(configDir).mkdirs();
}
- Bundles.setDirectory(configDir);
-
- uiconfig = new UiConfigBundle();
- trans = new StringIdBundle(getLang());
-
- boolean debug = Instance.getConfig()
- .getBoolean(Config.DEBUG_ERR, false);
- boolean trace = Instance.getConfig().getBoolean(Config.DEBUG_TRACE,
- false);
- coverDir = getFile(Config.DEFAULT_COVERS_DIR);
- File tmp = getFile(Config.CACHE_DIR);
- readerTmp = getFile(UiConfig.CACHE_DIR_LOCAL_READER);
- remoteDir = new File(configDir, "remote");
+ // Most of the rest is dependent upon this:
+ createConfigs(configDir, false);
- if (checkEnv("NOUTF")) {
- trans.setUnicode(false);
- }
+ // Proxy support
+ Proxy.use(config.getString(Config.NETWORK_PROXY));
- if (checkEnv("DEBUG")) {
- debug = true;
+ // update tracer:
+ if (debug == null) {
+ debug = config.getBoolean(Config.DEBUG_ERR, false);
+ trace = config.getBoolean(Config.DEBUG_TRACE, false);
}
tracer = new TraceHandler(true, debug, trace);
- String remoteLib = config.getString(Config.DEFAULT_LIBRARY);
- if (remoteLib == null || remoteLib.trim().isEmpty()) {
- try {
- lib = new LocalLibrary(getFile(Config.LIBRARY_DIR));
- } catch (Exception e) {
- tracer.error(new IOException(
- "Cannot create library for directory: "
- + getFile(Config.LIBRARY_DIR), e));
- }
- } else {
- int pos = remoteLib.lastIndexOf(":");
- if (pos >= 0) {
- String port = remoteLib.substring(pos + 1).trim();
- remoteLib = remoteLib.substring(0, pos);
- pos = remoteLib.lastIndexOf(":");
- if (pos >= 0) {
- String host = remoteLib.substring(pos + 1).trim();
- String key = remoteLib.substring(0, pos).trim();
-
- try {
- tracer.trace("Contacting remote library " + host + ":"
- + port);
- lib = new RemoteLibrary(key, host,
- Integer.parseInt(port));
- } catch (Exception e) {
- }
- }
- }
-
- if (lib == null) {
- tracer.error(new IOException(
- "Cannot create remote library for: "
- + getFile(Config.DEFAULT_LIBRARY)));
- }
- }
-
- // Could have used: System.getProperty("java.io.tmpdir")
- if (tmp == null) {
- tmp = new File(configDir, "tmp");
- }
- if (readerTmp == null) {
- readerTmp = new File(configDir, "tmp-reader");
- }
- //
+ // default Library
+ remoteDir = new File(configDir, "remote");
+ lib = createDefaultLibrary(remoteDir);
- if (coverDir != null && !coverDir.exists()) {
- tracer.error(new IOException(
- "The 'default covers' directory does not exists: "
- + coverDir));
- coverDir = null;
- }
+ // create cache and TMP
+ File tmp = getFile(Config.CACHE_DIR, configDir, "tmp");
+ Image.setTemporaryFilesRoot(new File(tmp.getParent(), "tmp.images"));
+ String ua = config.getString(Config.NETWORK_USER_AGENT, "");
try {
- String ua = config.getString(Config.USER_AGENT);
- int hours = config.getInteger(Config.CACHE_MAX_TIME_CHANGING, -1);
- int hoursLarge = config
- .getInteger(Config.CACHE_MAX_TIME_STABLE, -1);
-
+ int hours = config.getInteger(Config.CACHE_MAX_TIME_CHANGING, 0);
+ int hoursLarge = config.getInteger(Config.CACHE_MAX_TIME_STABLE, 0);
cache = new DataLoader(tmp, ua, hours, hoursLarge);
} catch (IOException e) {
tracer.error(new IOException(
"Cannot create cache (will continue without cache)", e));
+ cache = new DataLoader(ua);
+ }
+
+ cache.setTraceHandler(tracer);
+
+ // readerTmp / coverDir
+ readerTmp = getFile(UiConfig.CACHE_DIR_LOCAL_READER, configDir,
+ "tmp-reader");
+ coverDir = getFile(Config.DEFAULT_COVERS_DIR, configDir, "covers");
+ coverDir.mkdirs();
+
+ try {
+ tempFiles = new TempFiles("fanfix");
+ } catch (IOException e) {
+ tracer.error(
+ new IOException("Cannot create temporary directory", e));
}
}
*
* @return the traces handler (never NULL)
*/
- public static TraceHandler getTraceHandler() {
+ public TraceHandler getTraceHandler() {
return tracer;
}
* @param tracer
* the new traces handler or NULL
*/
- public static void setTraceHandler(TraceHandler tracer) {
+ public void setTraceHandler(TraceHandler tracer) {
if (tracer == null) {
tracer = new TraceHandler(false, false, false);
}
- Instance.tracer = tracer;
+ this.tracer = tracer;
+ cache.setTraceHandler(tracer);
}
/**
*
* @return the configuration service
*/
- public static ConfigBundle getConfig() {
+ public ConfigBundle getConfig() {
return config;
}
*
* @return the configuration service
*/
- public static UiConfigBundle getUiConfig() {
+ public UiConfigBundle getUiConfig() {
return uiconfig;
}
+ /**
+ * Reset the configuration.
+ *
+ * @param resetTrans
+ * also reset the translation files
+ */
+ public void resetConfig(boolean resetTrans) {
+ String dir = Bundles.getDirectory();
+ Bundles.setDirectory(null);
+ try {
+ try {
+ ConfigBundle config = new ConfigBundle();
+ config.updateFile(configDir);
+ } catch (IOException e) {
+ tracer.error(e);
+ }
+ try {
+ UiConfigBundle uiconfig = new UiConfigBundle();
+ uiconfig.updateFile(configDir);
+ } catch (IOException e) {
+ tracer.error(e);
+ }
+
+ if (resetTrans) {
+ try {
+ StringIdBundle trans = new StringIdBundle(null);
+ trans.updateFile(configDir);
+ } catch (IOException e) {
+ tracer.error(e);
+ }
+ }
+ } finally {
+ Bundles.setDirectory(dir);
+ }
+ }
+
/**
* Get the (unique) {@link DataLoader} for the program.
*
* @return the {@link DataLoader}
*/
- public static DataLoader getCache() {
+ public DataLoader getCache() {
return cache;
}
/**
* Get the (unique) {link StringIdBundle} for the program.
+ * <p>
+ * This is used for the translations of the core parts of Fanfix.
*
* @return the {link StringIdBundle}
*/
- public static StringIdBundle getTrans() {
+ public StringIdBundle getTrans() {
return trans;
}
/**
- * Get the (unique) {@link LocalLibrary} for the program.
+ * Get the (unique) {link StringIdGuiBundle} for the program.
+ * <p>
+ * This is used for the translations of the GUI parts of Fanfix.
+ *
+ * @return the {link StringIdGuiBundle}
+ */
+ public StringIdGuiBundle getTransGui() {
+ return transGui;
+ }
+
+ /**
+ * Get the (unique) {@link BasicLibrary} for the program.
*
- * @return the {@link LocalLibrary}
+ * @return the {@link BasicLibrary}
*/
- public static BasicLibrary getLibrary() {
+ public BasicLibrary getLibrary() {
if (lib == null) {
throw new NullPointerException("We don't have a library to return");
}
return lib;
}
+ /**
+ * Change the default {@link BasicLibrary} for this program.
+ * <p>
+ * Be careful.
+ *
+ * @param lib
+ * the new {@link BasicLibrary}
+ */
+ public void setLibrary(BasicLibrary lib) {
+ this.lib = lib;
+ }
+
/**
* Return the directory where to look for default cover pages.
*
* @return the default covers directory
*/
- public static File getCoverDir() {
+ public File getCoverDir() {
return coverDir;
}
*
* @return the directory
*/
- public static File getReaderDir() {
+ public File getReaderDir() {
return readerTmp;
}
*
* @return the directory
*/
- public static File getRemoteDir(String host) {
+ public File getRemoteDir(String host) {
+ return getRemoteDir(remoteDir, host);
+ }
+
+ /**
+ * Return the directory where to store temporary files for the remote
+ * {@link LocalLibrary}.
+ *
+ * @param remoteDir
+ * the base remote directory
+ * @param host
+ * the remote for this host
+ *
+ * @return the directory
+ */
+ private File getRemoteDir(File remoteDir, String host) {
remoteDir.mkdirs();
if (host != null) {
+ host = host.replace("fanfix://", "");
+ host = host.replace("http://", "");
+ host = host.replace("https://", "");
+ host = host.replaceAll("[^a-zA-Z0-9=+.-]", "_");
+
return new File(remoteDir, host);
}
*
* @return TRUE if we need to
*/
- public static boolean isVersionCheckNeeded() {
+ public boolean isVersionCheckNeeded() {
try {
- long wait = config.getInteger(Config.UPDATE_INTERVAL, 1) * 24 * 60
- * 60 * 1000;
+ long wait = config.getInteger(Config.NETWORK_UPDATE_INTERVAL, 0)
+ * 24 * 60 * 60 * 1000;
if (wait >= 0) {
- String lastUpString = IOUtils.readSmallFile(new File(configDir,
- "LAST_UPDATE"));
+ String lastUpString = IOUtils
+ .readSmallFile(new File(configDir, "LAST_UPDATE"));
long delay = new Date().getTime()
- Long.parseLong(lastUpString);
if (delay > wait) {
/**
* Notify that we checked for a new version of Fanfix.
*/
- public static void setVersionChecked() {
+ public void setVersionChecked() {
try {
IOUtils.writeSmallFile(new File(configDir), "LAST_UPDATE",
Long.toString(new Date().getTime()));
}
}
+ /**
+ * The facility to use temporary files in this program.
+ * <p>
+ * <b>MUST</b> be closed at end of program.
+ *
+ * @return the facility
+ */
+ public TempFiles getTempFiles() {
+ return tempFiles;
+ }
+
+ /**
+ * The configuration directory (will check, in order of preference, the
+ * system properties, the environment and then defaults to
+ * {@link Instance#getHome()}/.fanfix).
+ *
+ * @return the config directory
+ */
+ private String getConfigDir() {
+ String configDir = System.getProperty("CONFIG_DIR");
+
+ if (configDir == null) {
+ configDir = System.getenv("CONFIG_DIR");
+ }
+
+ if (configDir == null) {
+ configDir = new File(getHome(), ".fanfix").getPath();
+ }
+
+ return configDir;
+ }
+
+ /**
+ * Create the config variables ({@link Instance#config},
+ * {@link Instance#uiconfig}, {@link Instance#trans} and
+ * {@link Instance#transGui}).
+ *
+ * @param configDir
+ * the directory where to find the configuration files
+ * @param refresh
+ * TRUE to reset the configuration files from the default
+ * included ones
+ */
+ private void createConfigs(String configDir, boolean refresh) {
+ if (!refresh) {
+ Bundles.setDirectory(configDir);
+ }
+
+ try {
+ config = new ConfigBundle();
+ config.updateFile(configDir);
+ } catch (IOException e) {
+ tracer.error(e);
+ }
+
+ try {
+ uiconfig = new UiConfigBundle();
+ uiconfig.updateFile(configDir);
+ } catch (IOException e) {
+ tracer.error(e);
+ }
+
+ // No updateFile for this one! (we do not want the user to have custom
+ // translations that won't accept updates from newer versions)
+ trans = new StringIdBundle(getLang());
+ transGui = new StringIdGuiBundle(getLang());
+
+ // Fix an old bug (we used to store custom translation files by
+ // default):
+ if (trans.getString(StringId.INPUT_DESC_CBZ) == null) {
+ trans.deleteFile(configDir);
+ }
+
+ Boolean noutf = checkEnv("NOUTF");
+ if (noutf != null && noutf) {
+ trans.setUnicode(false);
+ transGui.setUnicode(false);
+ }
+
+ Bundles.setDirectory(configDir);
+ }
+
+ /**
+ * Create the default library as specified by the config.
+ *
+ * @param remoteDir
+ * the base remote directory if needed
+ *
+ * @return the default {@link BasicLibrary}
+ */
+ private BasicLibrary createDefaultLibrary(File remoteDir) {
+ BasicLibrary lib = null;
+
+ boolean useRemote = config.getBoolean(Config.REMOTE_LIBRARY_ENABLED,
+ false);
+ if (useRemote) {
+ String host = null;
+ int port = -1;
+ try {
+ host = config.getString(Config.REMOTE_LIBRARY_HOST,
+ "fanfix://localhost");
+ port = config.getInteger(Config.REMOTE_LIBRARY_PORT, -1);
+ String key = config.getString(Config.REMOTE_LIBRARY_KEY);
+
+ if (!host.startsWith("http://") && !host.startsWith("https://")
+ && !host.startsWith("fanfix://")) {
+ host = "fanfix://" + host;
+ }
+
+ tracer.trace("Selecting remote library " + host + ":" + port);
+
+ if (host.startsWith("fanfix://")) {
+ lib = new RemoteLibrary(key, host, port);
+ } else {
+ lib = new WebLibrary(key, host, port);
+ }
+
+ lib = new CacheLibrary(getRemoteDir(remoteDir, host), lib,
+ uiconfig);
+ } catch (Exception e) {
+ tracer.error(
+ new IOException("Cannot create remote library for: "
+ + host + ":" + port, e));
+ }
+ } else {
+ String libDir = System.getenv("BOOKS_DIR");
+ if (libDir == null || libDir.isEmpty()) {
+ libDir = getFile(Config.LIBRARY_DIR, configDir, "$HOME/Books")
+ .getPath();
+ }
+ try {
+ lib = new LocalLibrary(new File(libDir), config);
+ } catch (Exception e) {
+ tracer.error(new IOException(
+ "Cannot create library for directory: " + libDir, e));
+ }
+ }
+
+ return lib;
+ }
+
/**
* Return a path, but support the special $HOME variable.
*
- * @return the path
+ * @param id
+ * the key for the path, which may contain "$HOME"
+ * @param configDir
+ * the directory to use as base if not absolute
+ * @param def
+ * the default value if none (will be configDir-rooted if needed)
+ * @return the path, with expanded "$HOME" if needed
*/
- private static File getFile(Config id) {
- return getFile(config.getString(id));
+ protected File getFile(Config id, String configDir, String def) {
+ String path = config.getString(id, def);
+ return getFile(path, configDir);
}
/**
* Return a path, but support the special $HOME variable.
*
- * @return the path
+ * @param id
+ * the key for the path, which may contain "$HOME"
+ * @param configDir
+ * the directory to use as base if not absolute
+ * @param def
+ * the default value if none (will be configDir-rooted if needed)
+ * @return the path, with expanded "$HOME" if needed
*/
- private static File getFile(UiConfig id) {
- return getFile(uiconfig.getString(id));
+ protected File getFile(UiConfig id, String configDir, String def) {
+ String path = uiconfig.getString(id, def);
+ return getFile(path, configDir);
}
/**
* Return a path, but support the special $HOME variable.
*
- * @return the path
+ * @param path
+ * the path, which may contain "$HOME"
+ * @param configDir
+ * the directory to use as base if not absolute
+ * @return the path, with expanded "$HOME" if needed
*/
- private static File getFile(String path) {
+ protected File getFile(String path, String configDir) {
File file = null;
if (path != null && !path.isEmpty()) {
path = path.replace('/', File.separatorChar);
if (path.contains("$HOME")) {
- path = path.replace("$HOME",
- "" + System.getProperty("user.home"));
+ path = path.replace("$HOME", getHome());
+ } else if (!path.startsWith("/")) {
+ path = new File(configDir, path).getPath();
}
file = new File(path);
return file;
}
+ /**
+ * Return the home directory from the environment (FANFIX_DIR) or the system
+ * properties.
+ * <p>
+ * The environment variable is tested first. Then, the custom property
+ * "fanfix.home" is tried, followed by the usual "user.home" then
+ * "java.io.tmp" if nothing else is found.
+ *
+ * @return the home
+ */
+ protected String getHome() {
+ String home = System.getenv("FANFIX_DIR");
+ if (home != null && new File(home).isFile()) {
+ home = null;
+ }
+
+ if (home == null || home.trim().isEmpty()) {
+ home = System.getProperty("fanfix.home");
+ if (home != null && new File(home).isFile()) {
+ home = null;
+ }
+ }
+
+ if (home == null || home.trim().isEmpty()) {
+ home = System.getProperty("user.home");
+ if (!new File(home).isDirectory()) {
+ home = null;
+ }
+ }
+
+ if (home == null || home.trim().isEmpty()) {
+ home = System.getProperty("java.io.tmpdir");
+ if (!new File(home).isDirectory()) {
+ home = null;
+ }
+ }
+
+ if (home == null) {
+ home = "";
+ }
+
+ return home;
+ }
+
/**
* The language to use for the application (NULL = default system language).
*
* @return the language
*/
- private static String getLang() {
+ protected String getLang() {
String lang = config.getString(Config.LANG);
- if (System.getenv("LANG") != null && !System.getenv("LANG").isEmpty()) {
- lang = System.getenv("LANG");
+ if (lang == null || lang.isEmpty()) {
+ if (System.getenv("LANG") != null
+ && !System.getenv("LANG").isEmpty()) {
+ lang = System.getenv("LANG");
+ }
}
if (lang != null && lang.isEmpty()) {
*
* @return TRUE if it is
*/
- private static boolean checkEnv(String key) {
+ protected Boolean checkEnv(String key) {
String value = System.getenv(key);
if (value != null) {
value = value.trim().toLowerCase();
|| "y".equals(value)) {
return true;
}
+
+ return false;
}
- return false;
+ return null;
}
}