/* * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code 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 * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.util.prefs; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Timer; import java.util.TimerTask; import java.lang.ref.WeakReference; /* MacOSXPreferencesFile synchronization: Everything is synchronized on MacOSXPreferencesFile.class. This prevents: * simultaneous updates to cachedFiles or changedFiles * simultaneous creation of two objects for the same name+user+host triplet * simultaneous modifications to the same file * modifications during syncWorld/flushWorld * (in MacOSXPreferences.removeNodeSpi()) modification or sync during multi-step node removal process ... among other things. */ /* Timers. There are two timers that control synchronization of prefs data to and from disk. * Sync timer periodically calls syncWorld() to force external disk changes (e.g. from another VM) into the memory cache. The sync timer runs even if there are no outstanding local changes. The sync timer syncs all live MacOSXPreferencesFile objects (the cachedFiles list). The sync timer period is controlled by the java.util.prefs.syncInterval property (same as FileSystemPreferences). By default there is *no* sync timer (unlike FileSystemPreferences); it is only enabled if the syncInterval property is set. The minimum interval is 5 seconds. * Flush timer calls flushWorld() to force local changes to disk. The flush timer is scheduled to fire some time after each pref change, unless it's already scheduled to fire before that. syncWorld and flushWorld will cancel any outstanding flush timer as unnecessary. The flush timer flushes all changed files (the changedFiles list). The time between pref write and flush timer call is controlled by the java.util.prefs.flushDelay property (unlike FileSystemPreferences). The default is 60 seconds and the minimum is 5 seconds. The flush timer's behavior is required by the Java Preferences spec ("changes will eventually propagate to the persistent backing store with an implementation-dependent delay"). The sync timer is not required by the spec (multiple VMs are only required to not corrupt the prefs), but the periodic sync is implemented by FileSystemPreferences and may be useful to some programs. The sync timer is disabled by default because it's expensive and is usually not necessary. */ class MacOSXPreferencesFile { static { java.security.AccessController.doPrivileged( new java.security.PrivilegedAction() { public Void run() { System.loadLibrary("osx"); return null; } }); } private class FlushTask extends TimerTask { public void run() { MacOSXPreferencesFile.flushWorld(); } } private class SyncTask extends TimerTask { public void run() { MacOSXPreferencesFile.syncWorld(); } } // Maps string -> weak reference to MacOSXPreferencesFile private static HashMap> cachedFiles; // Files that may have unflushed changes private static HashSet changedFiles; // Timer and pending sync and flush tasks (which are both scheduled // on the same timer) private static Timer timer = null; private static FlushTask flushTimerTask = null; private static long flushDelay = -1; // in seconds (min 5, default 60) private static long syncInterval = -1; // (min 5, default negative == off) private String appName; private long user; private long host; String name() { return appName; } long user() { return user; } long host() { return host; } // private contructor - use factory method getFile() instead private MacOSXPreferencesFile(String newName, long newUser, long newHost) { appName = newName; user = newUser; host = newHost; } // Factory method // Always returns the same object for the given name+user+host static synchronized MacOSXPreferencesFile getFile(String newName, boolean isUser) { MacOSXPreferencesFile result = null; if (cachedFiles == null) cachedFiles = new HashMap<>(); String hashkey = newName + String.valueOf(isUser); WeakReference hashvalue = cachedFiles.get(hashkey); if (hashvalue != null) { result = hashvalue.get(); } if (result == null) { // Java user node == CF current user, any host // Java system node == CF any user, current host result = new MacOSXPreferencesFile(newName, isUser ? cfCurrentUser : cfAnyUser, isUser ? cfAnyHost : cfCurrentHost); cachedFiles.put(hashkey, new WeakReference(result)); } // Don't schedule this file for flushing until some nodes or // keys are added to it. // Do set up the sync timer if requested; sync timer affects reads // as well as writes. initSyncTimerIfNeeded(); return result; } // Write all prefs changes to disk and clear all cached prefs values // (so the next read will read from disk). static synchronized boolean syncWorld() { boolean ok = true; if (cachedFiles != null && !cachedFiles.isEmpty()) { Iterator> iter = cachedFiles.values().iterator(); while (iter.hasNext()) { WeakReference ref = iter.next(); MacOSXPreferencesFile f = ref.get(); if (f != null) { if (!f.synchronize()) ok = false; } else { iter.remove(); } } } // Kill any pending flush if (flushTimerTask != null) { flushTimerTask.cancel(); flushTimerTask = null; } // Clear changed file list. The changed files were guaranteed to // have been in the cached file list (because there was a strong // reference from changedFiles. if (changedFiles != null) changedFiles.clear(); return ok; } // Sync only current user preferences static synchronized boolean syncUser() { boolean ok = true; if (cachedFiles != null && !cachedFiles.isEmpty()) { Iterator> iter = cachedFiles.values().iterator(); while (iter.hasNext()) { WeakReference ref = iter.next(); MacOSXPreferencesFile f = ref.get(); if (f != null && f.user == cfCurrentUser) { if (!f.synchronize()) { ok = false; } } else { iter.remove(); } } } // Remove synchronized file from changed file list. The changed files were // guaranteed to have been in the cached file list (because there was a strong // reference from changedFiles. if (changedFiles != null) { Iterator iterChanged = changedFiles.iterator(); while (iterChanged.hasNext()) { MacOSXPreferencesFile f = iterChanged.next(); if (f != null && f.user == cfCurrentUser) iterChanged.remove(); } } return ok; } // Write all prefs changes to disk, but do not clear all cached prefs // values. Also kills any scheduled flush task. // There's no CFPreferencesFlush() (), so lots of cached prefs // are cleared anyway. static synchronized boolean flushWorld() { boolean ok = true; if (changedFiles != null && !changedFiles.isEmpty()) { for (MacOSXPreferencesFile f : changedFiles) { if (!f.synchronize()) ok = false; } changedFiles.clear(); } if (flushTimerTask != null) { flushTimerTask.cancel(); flushTimerTask = null; } return ok; } // Mark this prefs file as changed. The changes will be flushed in // at most flushDelay() seconds. // Must be called when synchronized on MacOSXPreferencesFile.class private void markChanged() { // Add this file to the changed file list if (changedFiles == null) changedFiles = new HashSet<>(); changedFiles.add(this); // Schedule a new flush and a shutdown hook, if necessary if (flushTimerTask == null) { flushTimerTask = new FlushTask(); timer().schedule(flushTimerTask, flushDelay() * 1000); } } // Return the flush delay, initializing from a property if necessary. private static synchronized long flushDelay() { if (flushDelay == -1) { try { // flush delay >= 5, default 60 flushDelay = Math.max(5, Integer.parseInt(System.getProperty("java.util.prefs.flushDelay", "60"))); } catch (NumberFormatException e) { flushDelay = 60; } } return flushDelay; } // Initialize and run the sync timer, if the sync timer property is set // and the sync timer hasn't already been started. private static synchronized void initSyncTimerIfNeeded() { // syncInterval: -1 is uninitialized, other negative is off, // positive is seconds between syncs (min 5). if (syncInterval == -1) { try { syncInterval = Integer.parseInt(System.getProperty("java.util.prefs.syncInterval", "-2")); if (syncInterval >= 0) { // minimum of 5 seconds syncInterval = Math.max(5, syncInterval); } else { syncInterval = -2; // default off } } catch (NumberFormatException e) { syncInterval = -2; // bad property value - default off } if (syncInterval > 0) { timer().schedule(new TimerTask() { @Override public void run() { MacOSXPreferencesFile.syncWorld();} }, syncInterval * 1000, syncInterval * 1000); } else { // syncInterval property not set. No sync timer ever. } } } // Return the timer used for flush and sync, creating it if necessary. private static synchronized Timer timer() { if (timer == null) { timer = new Timer(true); // daemon Thread flushThread = new Thread() { @Override public void run() { flushWorld(); } }; /* Set context class loader to null in order to avoid * keeping a strong reference to an application classloader. */ flushThread.setContextClassLoader(null); Runtime.getRuntime().addShutdownHook(flushThread); } return timer; } // Node manipulation boolean addNode(String path) { synchronized(MacOSXPreferencesFile.class) { markChanged(); return addNode(path, appName, user, host); } } void removeNode(String path) { synchronized(MacOSXPreferencesFile.class) { markChanged(); removeNode(path, appName, user, host); } } boolean addChildToNode(String path, String child) { synchronized(MacOSXPreferencesFile.class) { markChanged(); return addChildToNode(path, child+"/", appName, user, host); } } void removeChildFromNode(String path, String child) { synchronized(MacOSXPreferencesFile.class) { markChanged(); removeChildFromNode(path, child+"/", appName, user, host); } } // Key manipulation void addKeyToNode(String path, String key, String value) { synchronized(MacOSXPreferencesFile.class) { markChanged(); addKeyToNode(path, key, value, appName, user, host); } } void removeKeyFromNode(String path, String key) { synchronized(MacOSXPreferencesFile.class) { markChanged(); removeKeyFromNode(path, key, appName, user, host); } } String getKeyFromNode(String path, String key) { synchronized(MacOSXPreferencesFile.class) { return getKeyFromNode(path, key, appName, user, host); } } // Enumerators String[] getChildrenForNode(String path) { synchronized(MacOSXPreferencesFile.class) { return getChildrenForNode(path, appName, user, host); } } String[] getKeysForNode(String path) { synchronized(MacOSXPreferencesFile.class) { return getKeysForNode(path, appName, user, host); } } // Synchronization boolean synchronize() { synchronized(MacOSXPreferencesFile.class) { return synchronize(appName, user, host); } } // CF functions // Must be called when synchronized on MacOSXPreferencesFile.class private static final native boolean addNode(String path, String name, long user, long host); private static final native void removeNode(String path, String name, long user, long host); private static final native boolean addChildToNode(String path, String child, String name, long user, long host); private static final native void removeChildFromNode(String path, String child, String name, long user, long host); private static final native void addKeyToNode(String path, String key, String value, String name, long user, long host); private static final native void removeKeyFromNode(String path, String key, String name, long user, long host); private static final native String getKeyFromNode(String path, String key, String name, long user, long host); private static final native String[] getChildrenForNode(String path, String name, long user, long host); private static final native String[] getKeysForNode(String path, String name, long user, long host); private static final native boolean synchronize(String name, long user, long host); // CFPreferences host and user values (CFStringRefs) private static long cfCurrentUser = currentUser(); private static long cfAnyUser = anyUser(); private static long cfCurrentHost = currentHost(); private static long cfAnyHost = anyHost(); // CFPreferences constant accessors private static final native long currentUser(); private static final native long anyUser(); private static final native long currentHost(); private static final native long anyHost(); }