WindhoverLabs / phoebus / #69

Committed 26 Aug 2023 11:53PM UTC coverage: 16.527% (-0.02%) from 16.543%

Build # #69

Build Type

push

Committed by

Commit Message

-CSV Exporter functional

Run Details

17716 of 107197 relevant lines covered (16.53%)

0.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

37.39

/core/framework/src/main/java/org/phoebus/framework/preferences/FileSystemPreferences.java

/*
 * Copyright 2000-2006 Sun Microsystems, Inc.  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.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

package org.phoebus.framework.preferences;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileLock;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.AbstractPreferences;
import java.util.prefs.BackingStoreException;
import java.util.prefs.InvalidPreferencesFormatException;
import java.util.prefs.Preferences;

import org.phoebus.framework.workbench.Locations;

/**
 * Preferences implementation for Unix. Preferences are stored in the file
 * system, with one directory per preferences node. All of the preferences at
 * each node are stored in a single file. Atomic file system operations (e.g.
 * File.renameTo) are used to ensure integrity. An in-memory cache of the
 * "explored" portion of the tree is maintained for performance, and written
 * back to the disk periodically. File-locking is used to ensure reasonable
 * behavior when multiple VMs are running at the same time. (The file lock is
 * obtained only for sync(), flush() and removeNode().)
 *
 * @author Josh Bloch
 * @see Preferences
 * @since 1.4
 */

@SuppressWarnings({"unchecked", "nls"})
class FileSystemPreferences extends AbstractPreferences {

    /**
     * Sync interval in seconds.
     */
    private static final int SYNC_INTERVAL = Math.max(1,
            Integer.parseInt(AccessController.doPrivileged(new PrivilegedAction<String>() {
                @Override
                public String run() {
                    return System.getProperty("java.util.prefs.syncInterval", "30");
                }
            })));

    /**
     * Returns logger for error messages. Backing store exceptions are logged at
     * WARNING level.
     */
    private static Logger getLogger() {
        return Logger.getLogger("java.util.prefs");
    }

    /**
     * Directory for system preferences.
     */
    private static File systemRootDir;

    /*
     * Flag, indicating whether systemRoot directory is writable
     */
    private static boolean isSystemRootWritable;

    /**
     * Directory for user preferences.
     */
    private static File userRootDir;

    /*
     * Flag, indicating whether userRoot directory is writable
     */
    private static boolean isUserRootWritable;

    /**
     * The user root.
     */
    static Preferences userRoot = null;

    static synchronized Preferences getUserRoot() {
        if (userRoot == null) {
            setupUserRoot();
            userRoot = new FileSystemPreferences(true);
        }
        return userRoot;
    }

    private static void setupUserRoot() {
        AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public Object run() {

                // If Phoebus locations have been set,
                // place the user preferences in the user directory that also stores mementos etc.
                // Otherwise fall back to original FileSystemPreferences behavior
                if (System.getProperty(Locations.PHOEBUS_USER, "").length() > 0)
                    userRootDir = new File(System.getProperty(Locations.PHOEBUS_USER), ".userPrefs");
                else
                    userRootDir = new File(System.getProperty("java.util.prefs.userRoot", System.getProperty("user.home")),
                        ".phoebus/.userPrefs");

                // Attempt to create root dir if it does not yet exist.
                if (!userRootDir.exists()) {
                    if (userRootDir.mkdirs()) {
                        getLogger().info("Created user preferences directory.");
                    } else
                        getLogger().warning(
                                "Couldn't create user preferences" + " directory. User preferences are unusable.");
                }
                isUserRootWritable = userRootDir.canWrite();
                String USER_NAME = System.getProperty("user.name");
                userLockFile = new File(userRootDir, ".user.lock." + USER_NAME);
                userRootModFile = new File(userRootDir, ".userRootModFile." + USER_NAME);
                if (!userRootModFile.exists())
                    try {
                        // create if does not exist.
                        userRootModFile.createNewFile();
                    } catch (IOException e) {
                        getLogger().warning(e.toString());
                    }
                userRootModTime = userRootModFile.lastModified();
                return null;
            }
        });
    }

    /**
     * The system root.
     */
    static Preferences systemRoot;

    static synchronized Preferences getSystemRoot() {
        if (systemRoot == null) {
            setupSystemRoot();
            systemRoot = new FileSystemPreferences(false);
        }
        return systemRoot;
    }

    private static void setupSystemRoot() {
        AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public Object run() {
                String systemPrefsDirName = System.getProperty("java.util.prefs.systemRoot", "/etc/.java");
                systemRootDir = new File(systemPrefsDirName, ".systemPrefs");
                // Attempt to create root dir if it does not yet exist.
                if (!systemRootDir.exists()) {
                    // system root does not exist in /etc/.java
                    // Switching to java.home
                    systemRootDir = new File(System.getProperty("java.home"), ".systemPrefs");
                    if (!systemRootDir.exists()) {
                        if (systemRootDir.mkdirs()) {
                            getLogger().info("Created system preferences directory " + "in java.home.");
                        } else {
                            getLogger().warning("Could not create " + "system preferences directory. System "
                                    + "preferences are unusable.");
                        }
                    }
                }
                isSystemRootWritable = systemRootDir.canWrite();
                systemLockFile = new File(systemRootDir, ".system.lock");
                systemRootModFile = new File(systemRootDir, ".systemRootModFile");
                if (!systemRootModFile.exists() && isSystemRootWritable)
                    try {
                        // create if does not exist.
                        systemRootModFile.createNewFile();
                    } catch (IOException e) {
                        getLogger().warning(e.toString());
                    }
                systemRootModTime = systemRootModFile.lastModified();
                return null;
            }
        });
    }

    /**
     * The lock file for the user tree.
     */
    static File userLockFile;

    /**
     * The lock file for the system tree.
     */
    static File systemLockFile;

    /**
     * Unix lock handle for userRoot. Zero, if unlocked.
     */

    private static RandomAccessFile userRootLockFile = null;
    private static FileLock userRootLockHandle = null;

    /**
     * Unix lock handle for systemRoot. Zero, if unlocked.
     */

    private static RandomAccessFile systemRootLockFile = null;
    private static FileLock systemRootLockHandle = null;

    /**
     * The directory representing this preference node. There is no guarantee that
     * this directory exits, as another VM can delete it at any time that it (the
     * other VM) holds the file-lock. While the root node cannot be deleted, it may
     * not yet have been created, or the underlying directory could have been
     * deleted accidentally.
     */
    private final File dir;

    /**
     * The file representing this preference node's preferences. The file format is
     * undocumented, and subject to change from release to release, but I'm sure
     * that you can figure it out if you try real hard.
     */
    private final File prefsFile;

    /**
     * A temporary file used for saving changes to preferences. As part of the sync
     * operation, changes are first saved into this file, and then atomically
     * renamed to prefsFile. This results in an atomic state change from one valid
     * set of preferences to another. The the file-lock is held for the duration of
     * this transformation.
     */
    private final File tmpFile;

    /**
     * File, which keeps track of global modifications of userRoot.
     */
    private static File userRootModFile;

    /**
     * Flag, which indicated whether userRoot was modified by another VM
     */
    private static boolean isUserRootModified = false;

    /**
     * Keeps track of userRoot modification time. This time is reset to zero after
     * UNIX reboot, and is increased by 1 second each time userRoot is modified.
     */
    private static long userRootModTime;

    /*
     * File, which keeps track of global modifications of systemRoot
     */
    private static File systemRootModFile;
    /*
     * Flag, which indicates whether systemRoot was modified by another VM
     */
    private static boolean isSystemRootModified = false;

    /**
     * Keeps track of systemRoot modification time. This time is reset to zero after
     * system reboot, and is increased by 1 second each time systemRoot is modified.
     */
    private static long systemRootModTime;

    /**
     * Locally cached preferences for this node (includes uncommitted changes). This
     * map is initialized with from disk when the first get or put operation occurs
     * on this node. It is synchronized with the corresponding disk file (prefsFile)
     * by the sync operation. The initial value is read *without* acquiring the
     * file-lock.
     */
    private Map prefsCache = null;

    /**
     * The last modification time of the file backing this node at the time that
     * prefCache was last synchronized (or initially read). This value is set
     * *before* reading the file, so it's conservative; the actual timestamp could
     * be (slightly) higher. A value of zero indicates that we were unable to
     * initialize prefsCache from the disk, or have not yet attempted to do so. (If
     * prefsCache is non-null, it indicates the former; if it's null, the latter.)
     */
    private long lastSyncTime = 0;

    /**
     * Unix error code for locked file.
     */
    private static final int EAGAIN = 11;

    /**
     * Unix error code for denied access.
     */
    private static final int EACCES = 13;

    /**
     * A list of all uncommitted preference changes. The elements in this list are
     * of type PrefChange. If this node is concurrently modified on disk by another
     * VM, the two sets of changes are merged when this node is sync'ed by
     * overwriting our prefsCache with the preference map last written out to disk
     * (by the other VM), and then replaying this change log against that map. The
     * resulting map is then written back to the disk.
     */
    final List changeLog = new ArrayList();

    /**
     * Represents a change to a preference.
     */
    private abstract class Change {
        /**
         * Reapplies the change to prefsCache.
         */
        abstract void replay();
    };

    /**
     * Represents a preference put.
     */
    private class Put extends Change {
        String key, value;

        Put(String key, String value) {
            this.key = key;
            this.value = value;
        }

        @Override
        void replay() {
            prefsCache.put(key, value);
        }
    }

    /**
     * Represents a preference remove.
     */
    private class Remove extends Change {
        String key;

        Remove(String key) {
            this.key = key;
        }

        @Override
        void replay() {
            prefsCache.remove(key);
        }
    }

    /**
     * Represents the creation of this node.
     */
    private class NodeCreate extends Change {
        /**
         * Performs no action, but the presence of this object in changeLog will force
         * the node and its ancestors to be made permanent at the next sync.
         */
        @Override
        void replay() {
        }
    }

    /**
     * NodeCreate object for this node.
     */
    NodeCreate nodeCreate = null;

    /**
     * Replay changeLog against prefsCache.
     */
    private void replayChanges() {
        for (int i = 0, n = changeLog.size(); i < n; i++)
            ((Change) changeLog.get(i)).replay();
    }

    private static Timer syncTimer = new Timer(true); // Daemon Thread

    static {
        // Add periodic timer task to periodically sync cached prefs
        syncTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                syncWorld();
            }
        }, SYNC_INTERVAL * 1000, SYNC_INTERVAL * 1000);

        // Add shutdown hook to flush cached prefs on normal termination
        AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public Object run() {
                Runtime.getRuntime().addShutdownHook(new Thread() {
                    @Override
                    public void run() {
                        syncTimer.cancel();
                        syncWorld();
                    }
                });
                return null;
            }
        });
    }

    private static void syncWorld() {
        /*
         * Synchronization necessary because userRoot and systemRoot are lazily
         * initialized.
         */
        Preferences userRt;
        Preferences systemRt;
        synchronized (FileSystemPreferences.class) {
            userRt = userRoot;
            systemRt = systemRoot;
        }

        try {
            if (userRt != null)
                userRt.flush();
        } catch (BackingStoreException e) {
            getLogger().warning("Couldn't flush user prefs: " + e);
        }

        try {
            if (systemRt != null)
                systemRt.flush();
        } catch (BackingStoreException e) {
            getLogger().warning("Couldn't flush system prefs: " + e);
        }
    }

    private final boolean isUserNode;

    /**
     * Special constructor for roots (both user and system). This constructor will
     * only be called twice, by the static initializer.
     */
    private FileSystemPreferences(boolean user) {
        super(null, "");
        isUserNode = user;
        dir = (user ? userRootDir : systemRootDir);
        prefsFile = new File(dir, "prefs.xml");
        tmpFile = new File(dir, "prefs.tmp");
    }

    /**
     * Construct a new FileSystemPreferences instance with the specified parent node
     * and name. This constructor, called from childSpi, is used to make every node
     * except for the two //roots.
     */
    private FileSystemPreferences(FileSystemPreferences parent, String name) {
        super(parent, name);
        isUserNode = parent.isUserNode;
        dir = new File(parent.dir, dirName(name));
        prefsFile = new File(dir, "prefs.xml");
        tmpFile = new File(dir, "prefs.tmp");
        AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public Object run() {
                newNode = !dir.exists();
                return null;
            }
        });
        if (newNode) {
            // These 2 things guarantee node will get wrtten at next flush/sync
            prefsCache = new TreeMap();
            nodeCreate = new NodeCreate();
            changeLog.add(nodeCreate);
        }
    }

    @Override
    public boolean isUserNode() {
        return isUserNode;
    }

    @Override
    protected void putSpi(String key, String value) {
        initCacheIfNecessary();
        changeLog.add(new Put(key, value));
        prefsCache.put(key, value);
    }

    @Override
    protected String getSpi(String key) {
        initCacheIfNecessary();
        return (String) prefsCache.get(key);
    }

    @Override
    protected void removeSpi(String key) {
        initCacheIfNecessary();
        changeLog.add(new Remove(key));
        prefsCache.remove(key);
    }

    /**
     * Initialize prefsCache if it has yet to be initialized. When this method
     * returns, prefsCache will be non-null. If the data was successfully read from
     * the file, lastSyncTime will be updated. If prefsCache was null, but it was
     * impossible to read the file (because it didn't exist or for any other reason)
     * prefsCache will be initialized to an empty, modifiable Map, and lastSyncTime
     * remain zero.
     */
    private void initCacheIfNecessary() {
        if (prefsCache != null)
            return;

        try {
            loadCache();
        } catch (Exception e) {
            // assert lastSyncTime == 0;
            prefsCache = new TreeMap();
        }
    }

    /**
     * Attempt to load prefsCache from the backing store. If the attempt succeeds,
     * lastSyncTime will be updated (the new value will typically correspond to the
     * data loaded into the map, but it may be less, if another VM is updating this
     * node concurrently). If the attempt fails, a BackingStoreException is thrown
     * and both prefsCache and lastSyncTime are unaffected by the call.
     */
    private void loadCache() throws BackingStoreException {
        try {
            AccessController.doPrivileged(new PrivilegedExceptionAction() {
                @Override
                public Object run() throws BackingStoreException {
                    Map m = new TreeMap();
                    long newLastSyncTime = 0;
                    try {
                        newLastSyncTime = prefsFile.lastModified();
                        FileInputStream fis = new FileInputStream(prefsFile);
                        FilePreferencesXmlSupport.importMap(fis, m);
                        fis.close();
                    } catch (Exception e) {
                        if (e instanceof InvalidPreferencesFormatException) {
                            getLogger().warning("Invalid preferences format in " + prefsFile.getPath());
                            prefsFile.renameTo(new File(prefsFile.getParentFile(), "IncorrectFormatPrefs.xml"));
                            m = new TreeMap();
                        } else if (e instanceof FileNotFoundException) {
                            getLogger().warning("Prefs file removed in background " + prefsFile.getPath());
                        } else {
                            throw new BackingStoreException(e);
                        }
                    }
                    // Attempt succeeded; update state
                    prefsCache = m;
                    lastSyncTime = newLastSyncTime;
                    return null;
                }
            });
        } catch (PrivilegedActionException e) {
            throw (BackingStoreException) e.getException();
        }
    }

    /**
     * Attempt to write back prefsCache to the backing store. If the attempt
     * succeeds, lastSyncTime will be updated (the new value will correspond exactly
     * to the data thust written back, as we hold the file lock, which prevents a
     * concurrent write. If the attempt fails, a BackingStoreException is thrown and
     * both the backing store (prefsFile) and lastSyncTime will be unaffected by
     * this call. This call will NEVER leave prefsFile in a corrupt state.
     */
    private void writeBackCache() throws BackingStoreException {
        try {
            AccessController.doPrivileged(new PrivilegedExceptionAction() {
                @Override
                public Object run() throws BackingStoreException {
                    try {
                        if (!dir.exists() && !dir.mkdirs())
                            throw new BackingStoreException(dir + " create failed.");
                        FileOutputStream fos = new FileOutputStream(tmpFile);
                        FilePreferencesXmlSupport.exportMap(fos, prefsCache);
                        fos.close();
                        Files.move(tmpFile.toPath(), prefsFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
                    } catch (Exception e) {
                        throw new BackingStoreException(e);
                    }
                    return null;
                }
            });
        } catch (PrivilegedActionException e) {
            throw (BackingStoreException) e.getException();
        }
    }

    @Override
    protected String[] keysSpi() {
        initCacheIfNecessary();
        return (String[]) prefsCache.keySet().toArray(new String[prefsCache.size()]);
    }

    @Override
    protected String[] childrenNamesSpi() {
        return (String[]) AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public Object run() {
                List result = new ArrayList();
                File[] dirContents = dir.listFiles();
                if (dirContents != null) {
                    for (int i = 0; i < dirContents.length; i++)
                        if (dirContents[i].isDirectory())
                            result.add(nodeName(dirContents[i].getName()));
                }
                return result.toArray(EMPTY_STRING_ARRAY);
            }
        });
    }

    private static final String[] EMPTY_STRING_ARRAY = new String[0];

    @Override
    protected AbstractPreferences childSpi(String name) {
        return new FileSystemPreferences(this, name);
    }

    @Override
    public void removeNode() throws BackingStoreException {
        synchronized (isUserNode() ? userLockFile : systemLockFile) {
            // to remove a node we need an exclusive lock
            if (!lockFile(false))
                throw (new BackingStoreException("Couldn't get file lock."));
            try {
                super.removeNode();
            } finally {
                unlockFile();
            }
        }
    }

    /**
     * Called with file lock held (in addition to node locks).
     */
    @Override
    protected void removeNodeSpi() throws BackingStoreException {
        try {
            AccessController.doPrivileged(new PrivilegedExceptionAction() {
                @Override
                public Object run() throws BackingStoreException {
                    if (changeLog.contains(nodeCreate)) {
                        changeLog.remove(nodeCreate);
                        nodeCreate = null;
                        return null;
                    }
                    if (!dir.exists())
                        return null;
                    prefsFile.delete();
                    tmpFile.delete();
                    // dir should be empty now. If it's not, empty it
                    File[] junk = dir.listFiles();
                    if (junk.length != 0) {
                        getLogger().warning("Found extraneous files when removing node: " + Arrays.asList(junk));
                        for (int i = 0; i < junk.length; i++)
                            junk[i].delete();
                    }
                    if (!dir.delete())
                        throw new BackingStoreException("Couldn't delete dir: " + dir);
                    return null;
                }
            });
        } catch (PrivilegedActionException e) {
            throw (BackingStoreException) e.getException();
        }
    }

    @Override
    public synchronized void sync() throws BackingStoreException {
        boolean userNode = isUserNode();
        boolean shared;

        if (userNode) {
            shared = false; /* use exclusive lock for user prefs */
        } else {
            /*
             * if can write to system root, use exclusive lock. otherwise use shared lock.
             */
            shared = !isSystemRootWritable;
        }
        synchronized (isUserNode() ? userLockFile : systemLockFile) {
            if (!lockFile(shared))
                throw (new BackingStoreException("Couldn't get file lock."));
            final Long newModTime = (Long) AccessController.doPrivileged(new PrivilegedAction() {
                @Override
                public Object run() {
                    long nmt;
                    if (isUserNode()) {
                        nmt = userRootModFile.lastModified();
                        isUserRootModified = userRootModTime == nmt;
                    } else {
                        nmt = systemRootModFile.lastModified();
                        isSystemRootModified = systemRootModTime == nmt;
                    }
                    return Long.valueOf(nmt);
                }
            });
            try {
                super.sync();
                AccessController.doPrivileged(new PrivilegedAction() {
                    @Override
                    public Object run() {
                        if (isUserNode()) {
                            userRootModTime = newModTime.longValue() + 1000;
                            userRootModFile.setLastModified(userRootModTime);
                        } else {
                            systemRootModTime = newModTime.longValue() + 1000;
                            systemRootModFile.setLastModified(systemRootModTime);
                        }
                        return null;
                    }
                });
            } finally {
                unlockFile();
            }
        }
    }

    @Override
    protected void syncSpi() throws BackingStoreException {
        try {
            AccessController.doPrivileged(new PrivilegedExceptionAction() {
                @Override
                public Object run() throws BackingStoreException {
                    syncSpiPrivileged();
                    return null;
                }
            });
        } catch (PrivilegedActionException e) {
            throw (BackingStoreException) e.getException();
        }
    }

    private void syncSpiPrivileged() throws BackingStoreException {
        if (isRemoved())
            throw new IllegalStateException("Node has been removed");
        if (prefsCache == null)
            return; // We've never been used, don't bother syncing
        long lastModifiedTime;
        if ((isUserNode() ? isUserRootModified : isSystemRootModified)) {
            lastModifiedTime = prefsFile.lastModified();
            if (lastModifiedTime != lastSyncTime) {
                // Prefs at this node were externally modified; read in node and
                // playback any local mods since last sync
                loadCache();
                replayChanges();
                lastSyncTime = lastModifiedTime;
            }
        } else if (lastSyncTime != 0 && !dir.exists()) {
            // This node was removed in the background. Playback any changes
            // against a virgin (empty) Map.
            prefsCache = new TreeMap();
            replayChanges();
        }
        if (!changeLog.isEmpty()) {
            writeBackCache(); // Creates directory & file if necessary
            /*
             * Attempt succeeded; it's barely possible that the call to lastModified might
             * fail (i.e., return 0), but this would not be a disaster, as lastSyncTime is
             * allowed to lag.
             */
            lastModifiedTime = prefsFile.lastModified();
            /*
             * If lastSyncTime did not change, or went back increment by 1 second. Since we
             * hold the lock lastSyncTime always monotonically encreases in the atomic
             * sense.
             */
            if (lastSyncTime <= lastModifiedTime) {
                lastSyncTime = lastModifiedTime + 1000;
                prefsFile.setLastModified(lastSyncTime);
            }
            changeLog.clear();
        }
    }

    @Override
    public void flush() throws BackingStoreException {
        if (isRemoved())
            return;
        sync();
    }

    @Override
    protected void flushSpi() throws BackingStoreException {
        // assert false;
    }

    @Override
    protected boolean isRemoved() {
        return super.isRemoved();
    }

    /**
     * Returns true if the specified character is appropriate for use in Unix
     * directory names. A character is appropriate if it's a printable ASCII
     * character (> 0x1f && < 0x7f) and unequal to slash ('/', 0x2f), dot ('.',
     * 0x2e), or underscore ('_', 0x5f).
     */
    private static boolean isDirChar(char ch) {
        return ch > 0x1f && ch < 0x7f && ch != '/' && ch != '.' && ch != '_';
    }

    /**
     * Returns the directory name corresponding to the specified node name.
     * Generally, this is just the node name. If the node name includes
     * inappropriate characters (as per isDirChar) it is translated to Base64. with
     * the underscore character ('_', 0x5f) prepended.
     */
    private static String dirName(String nodeName) {
        for (int i = 0, n = nodeName.length(); i < n; i++)
            if (!isDirChar(nodeName.charAt(i)))
                return "_" + Base64.byteArrayToAltBase64(byteArray(nodeName));
        return nodeName;
    }

    /**
     * Translate a string into a byte array by translating each character into two
     * bytes, high-byte first ("big-endian").
     */
    private static byte[] byteArray(String s) {
        int len = s.length();
        byte[] result = new byte[2 * len];
        for (int i = 0, j = 0; i < len; i++) {
            char c = s.charAt(i);
            result[j++] = (byte) (c >> 8);
            result[j++] = (byte) c;
        }
        return result;
    }

    /**
     * Returns the node name corresponding to the specified directory name. (Inverts
     * the transformation of dirName(String).
     */
    private static String nodeName(String dirName) {
        if (dirName.charAt(0) != '_')
            return dirName;
        byte a[] = Base64.altBase64ToByteArray(dirName.substring(1));
        StringBuffer result = new StringBuffer(a.length / 2);
        for (int i = 0; i < a.length;) {
            int highByte = a[i++] & 0xff;
            int lowByte = a[i++] & 0xff;
            result.append((char) ((highByte << 8) | lowByte));
        }
        return result.toString();
    }

    /**
     * Try to acquire the appropriate file lock (user or system). If the initial
     * attempt fails, several more attempts are made using an exponential backoff
     * strategy. If all attempts fail, this method returns false.
     *
     * @throws SecurityException
     *             if file access denied.
     */
    boolean lockFile(boolean shared) throws SecurityException {
        boolean usernode = isUserNode();
        int errorCode = 0;
        File lockFile = (usernode ? userLockFile : systemLockFile);
        long sleepTime = INIT_SLEEP_TIME;
        for (int i = 0; i < MAX_ATTEMPTS; i++) {
            try {
                RandomAccessFile file = new RandomAccessFile(lockFile.getCanonicalPath(), "rw");
                FileLock lock = file.getChannel().lock();

                if (lock != null) {
                    if (usernode) {
                        userRootLockFile = file;
                        userRootLockHandle = lock;
                    } else {
                        systemRootLockFile = file;
                        systemRootLockHandle = lock;
                    }
                    return true;
                }
            } catch (IOException e) {
            }

            try {
                Thread.sleep(sleepTime);
            } catch (InterruptedException e) {
                checkLockFile0ErrorCode(errorCode);
                return false;
            }
            sleepTime *= 2;
        }
        checkLockFile0ErrorCode(errorCode);
        return false;
    }

    /**
     * Checks if unlockFile0() returned an error. Throws a SecurityException, if
     * access denied. Logs a warning otherwise.
     */
    private void checkLockFile0ErrorCode(int errorCode) throws SecurityException {
        if (errorCode == EACCES)
            throw new SecurityException(
                    "Could not lock " + (isUserNode() ? "User prefs." : "System prefs.") + " Lock file access denied.");
        if (errorCode != EAGAIN)
            getLogger().warning("Could not lock " + (isUserNode() ? "User prefs. " : "System prefs.")
                    + " Unix error code " + errorCode + ".");
    }

    /**
     * Initial time between lock attempts, in ms. The time is doubled after each
     * failing attempt (except the first).
     */
    private static int INIT_SLEEP_TIME = 50;

    /**
     * Maximum number of lock attempts.
     */
    private static int MAX_ATTEMPTS = 5;

    /**
     * Release the the appropriate file lock (user or system).
     *
     * @throws SecurityException
     *             if file access denied.
     */
    void unlockFile() {
        boolean usernode = isUserNode();
        RandomAccessFile rootLockFile = (usernode ? userRootLockFile : systemRootLockFile);
        FileLock lockHandle = (usernode ? userRootLockHandle : systemRootLockHandle);
        try {
            lockHandle.close();
        } catch (IOException e) {
            getLogger().warning("Unlock: zero lockHandle for " + (usernode ? "user" : "system") + " preferences.)");
            return;
        } finally {
            try {
                rootLockFile.close();
            } catch (IOException e) {
                getLogger().log(Level.WARNING, "Cannot close lock file " + rootLockFile, e);
            }
        }

    }
}

WindhoverLabs / phoebus / #69

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous