1 /*
   2  * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.util.prefs;
  27 
  28 import java.util.HashMap;
  29 import java.util.HashSet;
  30 import java.util.Iterator;
  31 import java.util.Timer;
  32 import java.util.TimerTask;
  33 import java.lang.ref.WeakReference;
  34 
  35 
  36 /*
  37   MacOSXPreferencesFile synchronization:
  38 
  39   Everything is synchronized on MacOSXPreferencesFile.class. This prevents:
  40   * simultaneous updates to cachedFiles or changedFiles
  41   * simultaneous creation of two objects for the same name+user+host triplet
  42   * simultaneous modifications to the same file
  43   * modifications during syncWorld/flushWorld
  44   * (in MacOSXPreferences.removeNodeSpi()) modification or sync during
  45     multi-step node removal process
  46   ... among other things.
  47 */
  48 /*
  49   Timers. There are two timers that control synchronization of prefs data to
  50   and from disk.
  51 
  52   * Sync timer periodically calls syncWorld() to force external disk changes
  53       (e.g. from another VM) into the memory cache. The sync timer runs even
  54       if there are no outstanding local changes. The sync timer syncs all live
  55       MacOSXPreferencesFile objects (the cachedFiles list).
  56     The sync timer period is controlled by the java.util.prefs.syncInterval
  57       property (same as FileSystemPreferences). By default there is *no*
  58       sync timer (unlike FileSystemPreferences); it is only enabled if the
  59       syncInterval property is set. The minimum interval is 5 seconds.
  60 
  61   * Flush timer calls flushWorld() to force local changes to disk.
  62       The flush timer is scheduled to fire some time after each pref change,
  63       unless it's already scheduled to fire before that. syncWorld and
  64       flushWorld will cancel any outstanding flush timer as unnecessary.
  65       The flush timer flushes all changed files (the changedFiles list).
  66     The time between pref write and flush timer call is controlled by the
  67       java.util.prefs.flushDelay property (unlike FileSystemPreferences).
  68       The default is 60 seconds and the minimum is 5 seconds.
  69 
  70   The flush timer's behavior is required by the Java Preferences spec
  71   ("changes will eventually propagate to the persistent backing store with
  72   an implementation-dependent delay"). The sync timer is not required by
  73   the spec (multiple VMs are only required to not corrupt the prefs), but
  74   the periodic sync is implemented by FileSystemPreferences and may be
  75   useful to some programs. The sync timer is disabled by default because
  76   it's expensive and is usually not necessary.
  77 */
  78 
  79 class MacOSXPreferencesFile {
  80 
  81     static {
  82         java.security.AccessController.doPrivileged(
  83             new java.security.PrivilegedAction<Void>() {
  84                 public Void run() {
  85                     System.loadLibrary("osx");
  86                     return null;
  87                 }
  88             });
  89     }
  90 
  91     private class FlushTask extends TimerTask {
  92         public void run() {
  93             MacOSXPreferencesFile.flushWorld();
  94         }
  95     }
  96 
  97     private class SyncTask extends TimerTask {
  98         public void run() {
  99             MacOSXPreferencesFile.syncWorld();
 100         }
 101     }
 102 
 103     // Maps string -> weak reference to MacOSXPreferencesFile
 104     private static HashMap<String, WeakReference<MacOSXPreferencesFile>>
 105             cachedFiles;
 106     // Files that may have unflushed changes
 107     private static HashSet<MacOSXPreferencesFile> changedFiles;
 108 
 109 
 110     // Timer and pending sync and flush tasks (which are both scheduled
 111     // on the same timer)
 112     private static Timer timer = null;
 113     private static FlushTask flushTimerTask = null;
 114     private static long flushDelay = -1; // in seconds (min 5, default 60)
 115     private static long syncInterval = -1; // (min 5, default negative == off)
 116 
 117     private String appName;
 118     private long user;
 119     private long host;
 120 
 121     String name() { return appName; }
 122     long user() { return user; }
 123     long host() { return host; }
 124 
 125     // private contructor - use factory method getFile() instead
 126     private MacOSXPreferencesFile(String newName, long newUser, long newHost)
 127     {
 128         appName = newName;
 129         user = newUser;
 130         host = newHost;
 131     }
 132 
 133     // Factory method
 134     // Always returns the same object for the given name+user+host
 135     static synchronized MacOSXPreferencesFile
 136         getFile(String newName, boolean isUser)
 137     {
 138         MacOSXPreferencesFile result = null;
 139 
 140         if (cachedFiles == null)
 141             cachedFiles = new HashMap<>();
 142 
 143         String hashkey =
 144             newName + String.valueOf(isUser);
 145         WeakReference<MacOSXPreferencesFile> hashvalue = cachedFiles.get(hashkey);
 146         if (hashvalue != null) {
 147             result = hashvalue.get();
 148         }
 149         if (result == null) {
 150             // Java user node == CF current user, any host
 151             // Java system node == CF any user, current host
 152             result = new MacOSXPreferencesFile(newName,
 153                                          isUser ? cfCurrentUser : cfAnyUser,
 154                                          isUser ? cfAnyHost : cfCurrentHost);
 155             cachedFiles.put(hashkey, new WeakReference<MacOSXPreferencesFile>(result));
 156         }
 157 
 158         // Don't schedule this file for flushing until some nodes or
 159         // keys are added to it.
 160 
 161         // Do set up the sync timer if requested; sync timer affects reads
 162         // as well as writes.
 163         initSyncTimerIfNeeded();
 164 
 165         return result;
 166     }
 167 
 168 
 169     // Write all prefs changes to disk and clear all cached prefs values
 170     // (so the next read will read from disk).
 171     static synchronized boolean syncWorld()
 172     {
 173         boolean ok = true;
 174 
 175         if (cachedFiles != null  &&  !cachedFiles.isEmpty()) {
 176             Iterator<WeakReference<MacOSXPreferencesFile>> iter =
 177                     cachedFiles.values().iterator();
 178             while (iter.hasNext()) {
 179                 WeakReference<MacOSXPreferencesFile> ref = iter.next();
 180                 MacOSXPreferencesFile f = ref.get();
 181                 if (f != null) {
 182                     if (!f.synchronize()) ok = false;
 183                 } else {
 184                     iter.remove();
 185                 }
 186             }
 187         }
 188 
 189         // Kill any pending flush
 190         if (flushTimerTask != null) {
 191             flushTimerTask.cancel();
 192             flushTimerTask = null;
 193         }
 194 
 195         // Clear changed file list. The changed files were guaranteed to
 196         // have been in the cached file list (because there was a strong
 197         // reference from changedFiles.
 198         if (changedFiles != null) changedFiles.clear();
 199 
 200         return ok;
 201     }
 202 
 203 
 204     // Sync only current user preferences
 205     static synchronized boolean syncUser() {
 206         boolean ok = true;
 207         if (cachedFiles != null  &&  !cachedFiles.isEmpty()) {
 208             Iterator<WeakReference<MacOSXPreferencesFile>> iter =
 209                     cachedFiles.values().iterator();
 210             while (iter.hasNext()) {
 211                 WeakReference<MacOSXPreferencesFile> ref = iter.next();
 212                 MacOSXPreferencesFile f = ref.get();
 213                 if (f != null && f.user == cfCurrentUser) {
 214                     if (!f.synchronize()) {
 215                         ok = false;
 216                     }
 217                 } else {
 218                     iter.remove();
 219                 }
 220             }
 221         }
 222         // Remove synchronized file from changed file list. The changed files were
 223         // guaranteed to have been in the cached file list (because there was a strong
 224         // reference from changedFiles.
 225         if (changedFiles != null) {
 226             Iterator<MacOSXPreferencesFile> iterChanged = changedFiles.iterator();
 227             while (iterChanged.hasNext()) {
 228                 MacOSXPreferencesFile f = iterChanged.next();
 229                 if (f != null && f.user == cfCurrentUser)
 230                     iterChanged.remove();
 231              }
 232         }
 233         return ok;
 234     }
 235 
 236 
 237 
 238     // Write all prefs changes to disk, but do not clear all cached prefs
 239     // values. Also kills any scheduled flush task.
 240     // There's no CFPreferencesFlush() (<rdar://problem/3049129>), so lots of cached prefs
 241     // are cleared anyway.
 242     static synchronized boolean flushWorld()
 243     {
 244         boolean ok = true;
 245 
 246         if (changedFiles != null  &&  !changedFiles.isEmpty()) {
 247             for (MacOSXPreferencesFile f : changedFiles) {
 248                 if (!f.synchronize())
 249                     ok = false;
 250             }
 251             changedFiles.clear();
 252         }
 253 
 254         if (flushTimerTask != null) {
 255             flushTimerTask.cancel();
 256             flushTimerTask = null;
 257         }
 258 
 259         return ok;
 260     }
 261 
 262     // Mark this prefs file as changed. The changes will be flushed in
 263     // at most flushDelay() seconds.
 264     // Must be called when synchronized on MacOSXPreferencesFile.class
 265     private void markChanged()
 266     {
 267         // Add this file to the changed file list
 268         if (changedFiles == null)
 269             changedFiles = new HashSet<>();
 270         changedFiles.add(this);
 271 
 272         // Schedule a new flush and a shutdown hook, if necessary
 273         if (flushTimerTask == null) {
 274             flushTimerTask = new FlushTask();
 275             timer().schedule(flushTimerTask, flushDelay() * 1000);
 276         }
 277     }
 278 
 279     // Return the flush delay, initializing from a property if necessary.
 280     private static synchronized long flushDelay()
 281     {
 282         if (flushDelay == -1) {
 283             try {
 284                 // flush delay >= 5, default 60
 285                 flushDelay = Math.max(5, Integer.parseInt(System.getProperty("java.util.prefs.flushDelay", "60")));
 286             } catch (NumberFormatException e) {
 287                 flushDelay = 60;
 288             }
 289         }
 290         return flushDelay;
 291     }
 292 
 293     // Initialize and run the sync timer, if the sync timer property is set
 294     // and the sync timer hasn't already been started.
 295     private static synchronized void initSyncTimerIfNeeded()
 296     {
 297         // syncInterval: -1 is uninitialized, other negative is off,
 298         // positive is seconds between syncs (min 5).
 299 
 300         if (syncInterval == -1) {
 301             try {
 302                 syncInterval = Integer.parseInt(System.getProperty("java.util.prefs.syncInterval", "-2"));
 303                 if (syncInterval >= 0) {
 304                     // minimum of 5 seconds
 305                     syncInterval = Math.max(5, syncInterval);
 306                 } else {
 307                     syncInterval = -2; // default off
 308                 }
 309             } catch (NumberFormatException e) {
 310                 syncInterval = -2; // bad property value - default off
 311             }
 312 
 313             if (syncInterval > 0) {
 314                 timer().schedule(new TimerTask() {
 315                     @Override
 316                     public void run() {
 317                         MacOSXPreferencesFile.syncWorld();}
 318                     }, syncInterval * 1000, syncInterval * 1000);
 319             } else {
 320                 // syncInterval property not set. No sync timer ever.
 321             }
 322         }
 323     }
 324 
 325     // Return the timer used for flush and sync, creating it if necessary.
 326     private static synchronized Timer timer()
 327     {
 328         if (timer == null) {
 329             timer = new Timer(true); // daemon
 330             Thread flushThread = new Thread() {
 331                 @Override
 332                 public void run() {
 333                     flushWorld();
 334                 }
 335             };
 336             /* Set context class loader to null in order to avoid
 337              * keeping a strong reference to an application classloader.
 338              */
 339             flushThread.setContextClassLoader(null);
 340             Runtime.getRuntime().addShutdownHook(flushThread);
 341         }
 342         return timer;
 343     }
 344 
 345 
 346     // Node manipulation
 347     boolean addNode(String path)
 348     {
 349         synchronized(MacOSXPreferencesFile.class) {
 350             markChanged();
 351             return addNode(path, appName, user, host);
 352         }
 353     }
 354 
 355     void removeNode(String path)
 356     {
 357         synchronized(MacOSXPreferencesFile.class) {
 358             markChanged();
 359             removeNode(path, appName, user, host);
 360         }
 361     }
 362 
 363     boolean addChildToNode(String path, String child)
 364     {
 365         synchronized(MacOSXPreferencesFile.class) {
 366             markChanged();
 367             return addChildToNode(path, child+"/", appName, user, host);
 368         }
 369     }
 370 
 371     void removeChildFromNode(String path, String child)
 372     {
 373         synchronized(MacOSXPreferencesFile.class) {
 374             markChanged();
 375             removeChildFromNode(path, child+"/", appName, user, host);
 376         }
 377     }
 378 
 379 
 380     // Key manipulation
 381     void addKeyToNode(String path, String key, String value)
 382     {
 383         synchronized(MacOSXPreferencesFile.class) {
 384             markChanged();
 385             addKeyToNode(path, key, value, appName, user, host);
 386         }
 387     }
 388 
 389     void removeKeyFromNode(String path, String key)
 390     {
 391         synchronized(MacOSXPreferencesFile.class) {
 392             markChanged();
 393             removeKeyFromNode(path, key, appName, user, host);
 394         }
 395     }
 396 
 397     String getKeyFromNode(String path, String key)
 398     {
 399         synchronized(MacOSXPreferencesFile.class) {
 400             return getKeyFromNode(path, key, appName, user, host);
 401         }
 402     }
 403 
 404 
 405     // Enumerators
 406     String[] getChildrenForNode(String path)
 407     {
 408         synchronized(MacOSXPreferencesFile.class) {
 409             return getChildrenForNode(path, appName, user, host);
 410         }
 411     }
 412 
 413     String[] getKeysForNode(String path)
 414     {
 415         synchronized(MacOSXPreferencesFile.class) {
 416             return getKeysForNode(path, appName, user, host);
 417         }
 418     }
 419 
 420 
 421     // Synchronization
 422     boolean synchronize()
 423     {
 424         synchronized(MacOSXPreferencesFile.class) {
 425             return synchronize(appName, user, host);
 426         }
 427     }
 428 
 429 
 430     // CF functions
 431     // Must be called when synchronized on MacOSXPreferencesFile.class
 432     private static final native boolean
 433         addNode(String path, String name, long user, long host);
 434     private static final native void
 435         removeNode(String path, String name, long user, long host);
 436     private static final native boolean
 437         addChildToNode(String path, String child,
 438                        String name, long user, long host);
 439     private static final native void
 440         removeChildFromNode(String path, String child,
 441                             String name, long user, long host);
 442     private static final native void
 443         addKeyToNode(String path, String key, String value,
 444                      String name, long user, long host);
 445     private static final native void
 446         removeKeyFromNode(String path, String key,
 447                           String name, long user, long host);
 448     private static final native String
 449         getKeyFromNode(String path, String key,
 450                        String name, long user, long host);
 451     private static final native String[]
 452         getChildrenForNode(String path, String name, long user, long host);
 453     private static final native String[]
 454         getKeysForNode(String path, String name, long user, long host);
 455     private static final native boolean
 456         synchronize(String name, long user, long host);
 457 
 458     // CFPreferences host and user values (CFStringRefs)
 459     private static long cfCurrentUser = currentUser();
 460     private static long cfAnyUser = anyUser();
 461     private static long cfCurrentHost = currentHost();
 462     private static long cfAnyHost = anyHost();
 463 
 464     // CFPreferences constant accessors
 465     private static final native long currentUser();
 466     private static final native long anyUser();
 467     private static final native long currentHost();
 468     private static final native long anyHost();
 469 }
 470 
--- EOF ---