| /* |
| * Copyright (c) 2014, 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. |
| * |
| * 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. |
| */ |
| |
| /* |
| * @test |
| * @bug 8048020 |
| * @author Daniel Fuchs |
| * @summary Regression on java.util.logging.FileHandler. |
| * The fix is to avoid filling up the file system with zombie lock files. |
| * |
| * @run main/othervm CheckZombieLockTest WRITABLE CLOSE CLEANUP |
| * @run main/othervm CheckZombieLockTest CLEANUP |
| * @run main/othervm CheckZombieLockTest WRITABLE |
| * @run main/othervm CheckZombieLockTest CREATE_FIRST |
| * @run main/othervm CheckZombieLockTest CREATE_NEXT |
| * @run main/othervm CheckZombieLockTest CREATE_NEXT |
| * @run main/othervm CheckZombieLockTest CLEANUP |
| * @run main/othervm CheckZombieLockTest REUSE |
| * @run main/othervm CheckZombieLockTest CLEANUP |
| * @key randomness |
| */ |
| import java.io.File; |
| import java.io.IOException; |
| import java.nio.channels.FileChannel; |
| import java.nio.file.Paths; |
| import java.nio.file.StandardOpenOption; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.UUID; |
| import java.util.logging.FileHandler; |
| import java.util.logging.Level; |
| import java.util.logging.LogRecord; |
| public class CheckZombieLockTest { |
| |
| private static final String WRITABLE_DIR = "writable-lockfile-dir"; |
| private static volatile boolean supportsLocking = true; |
| |
| static enum TestCase { |
| WRITABLE, // just verifies that we can create a file in our 'writable-lockfile-dir' |
| CLOSE, // checks that closing a FileHandler removes its lock file |
| CREATE_FIRST, // verifies that 'writable-lockfile-dir' contains no lock, then creates a first FileHandler. |
| CREATE_NEXT, // verifies that 'writable-lockfile-dir' contains a single lock, then creates the next FileHandler |
| REUSE, // verifies that zombie lock files can be reused |
| CLEANUP // removes "writable-lockfile-dir" |
| }; |
| |
| public static void main(String... args) throws IOException { |
| // we'll base all file creation attempts on the system temp directory, |
| // %t |
| File writableDir = setup(); |
| System.out.println("Writable dir is: " + writableDir.getAbsolutePath()); |
| // we now have one writable directory to work with: |
| // writableDir |
| if (args == null || args.length == 0) { |
| args = new String[] { "WRITABLE", "CLOSE", "CLEANUP" }; |
| } |
| try { |
| runTests(writableDir, args); |
| } catch (RuntimeException | IOException | Error x) { |
| // some error occured: cleanup |
| delete(writableDir); |
| throw x; |
| } |
| } |
| |
| /** |
| * @param writableDir in which log and lock file are created |
| * @throws SecurityException |
| * @throws RuntimeException |
| * @throws IOException |
| */ |
| private static void runTests(File writableDir, String... args) throws SecurityException, |
| RuntimeException, IOException { |
| for (String arg : args) { |
| switch(TestCase.valueOf(arg)) { |
| // Test 1: makes sure we can create FileHandler in writable directory |
| case WRITABLE: checkWritable(writableDir); break; |
| // Test 2: verifies that FileHandler.close() cleans up its lock file |
| case CLOSE: testFileHandlerClose(writableDir); break; |
| // Test 3: creates the first file handler |
| case CREATE_FIRST: testFileHandlerCreate(writableDir, true); break; |
| // Test 4, 5, ... creates the next file handler |
| case CREATE_NEXT: testFileHandlerCreate(writableDir, false); break; |
| // Checks that zombie lock files are reused appropriatly |
| case REUSE: testFileHandlerReuse(writableDir); break; |
| // Removes the writableDir |
| case CLEANUP: delete(writableDir); break; |
| default: throw new RuntimeException("No such test case: " + arg); |
| } |
| } |
| } |
| |
| /** |
| * @param writableDir in which log and lock file are created |
| * @throws SecurityException |
| * @throws RuntimeException |
| * @throws IOException |
| */ |
| private static void checkWritable(File writableDir) throws SecurityException, |
| RuntimeException, IOException { |
| // Test 1: make sure we can create/delete files in the writable dir. |
| final File file = new File(writableDir, "test.txt"); |
| if (!createFile(file, false)) { |
| throw new IOException("Can't create " + file + "\n\tUnable to run test"); |
| } else { |
| delete(file); |
| } |
| } |
| |
| |
| private static FileHandler createFileHandler(File writableDir) throws SecurityException, |
| RuntimeException, IOException { |
| // Test 1: make sure we can create FileHandler in writable directory |
| try { |
| FileHandler handler = new FileHandler("%t/" + WRITABLE_DIR + "/log.log"); |
| handler.publish(new LogRecord(Level.INFO, handler.toString())); |
| handler.flush(); |
| return handler; |
| } catch (IOException ex) { |
| throw new RuntimeException("Test failed: should have been able" |
| + " to create FileHandler for " + "%t/" + WRITABLE_DIR |
| + "/log.log in writable directory.", ex); |
| } |
| } |
| |
| private static List<File> listLocks(File writableDir, boolean print) |
| throws IOException { |
| List<File> locks = new ArrayList<>(); |
| for (File f : writableDir.listFiles()) { |
| if (print) { |
| System.out.println("Found file: " + f.getName()); |
| } |
| if (f.getName().endsWith(".lck")) { |
| locks.add(f); |
| } |
| } |
| return locks; |
| } |
| |
| private static void testFileHandlerClose(File writableDir) throws IOException { |
| File fakeLock = new File(writableDir, "log.log.lck"); |
| if (!createFile(fakeLock, false)) { |
| throw new IOException("Can't create fake lock file: " + fakeLock); |
| } |
| try { |
| List<File> before = listLocks(writableDir, true); |
| System.out.println("before: " + before.size() + " locks found"); |
| FileHandler handler = createFileHandler(writableDir); |
| System.out.println("handler created: " + handler); |
| List<File> after = listLocks(writableDir, true); |
| System.out.println("after creating handler: " + after.size() + " locks found"); |
| handler.close(); |
| System.out.println("handler closed: " + handler); |
| List<File> afterClose = listLocks(writableDir, true); |
| System.out.println("after closing handler: " + afterClose.size() + " locks found"); |
| afterClose.removeAll(before); |
| if (!afterClose.isEmpty()) { |
| throw new RuntimeException("Zombie lock file detected: " + afterClose); |
| } |
| } finally { |
| if (fakeLock.canRead()) delete(fakeLock); |
| } |
| List<File> finalLocks = listLocks(writableDir, false); |
| System.out.println("After cleanup: " + finalLocks.size() + " locks found"); |
| } |
| |
| |
| private static void testFileHandlerReuse(File writableDir) throws IOException { |
| List<File> before = listLocks(writableDir, true); |
| System.out.println("before: " + before.size() + " locks found"); |
| try { |
| if (!before.isEmpty()) { |
| throw new RuntimeException("Expected no lock file! Found: " + before); |
| } |
| } finally { |
| before.stream().forEach(CheckZombieLockTest::delete); |
| } |
| |
| FileHandler handler1 = createFileHandler(writableDir); |
| System.out.println("handler created: " + handler1); |
| List<File> after = listLocks(writableDir, true); |
| System.out.println("after creating handler: " + after.size() + " locks found"); |
| if (after.size() != 1) { |
| throw new RuntimeException("Unexpected number of lock files found for " |
| + handler1 + ": " + after); |
| } |
| final File lock = after.get(0); |
| after.clear(); |
| handler1.close(); |
| after = listLocks(writableDir, true); |
| System.out.println("after closing handler: " + after.size() + " locks found"); |
| if (!after.isEmpty()) { |
| throw new RuntimeException("Unexpected number of lock files found for " |
| + handler1 + ": " + after); |
| } |
| if (!createFile(lock, false)) { |
| throw new IOException("Can't create fake lock file: " + lock); |
| } |
| try { |
| before = listLocks(writableDir, true); |
| System.out.println("before: " + before.size() + " locks found"); |
| if (before.size() != 1) { |
| throw new RuntimeException("Unexpected number of lock files found: " |
| + before + " expected [" + lock + "]."); |
| } |
| FileHandler handler2 = createFileHandler(writableDir); |
| System.out.println("handler created: " + handler2); |
| after = listLocks(writableDir, true); |
| System.out.println("after creating handler: " + after.size() + " locks found"); |
| after.removeAll(before); |
| if (!after.isEmpty()) { |
| throw new RuntimeException("Unexpected lock file found: " + after |
| + "\n\t" + lock + " should have been reused"); |
| } |
| handler2.close(); |
| System.out.println("handler closed: " + handler2); |
| List<File> afterClose = listLocks(writableDir, true); |
| System.out.println("after closing handler: " + afterClose.size() + " locks found"); |
| if (!afterClose.isEmpty()) { |
| throw new RuntimeException("Zombie lock file detected: " + afterClose); |
| } |
| |
| if (supportsLocking) { |
| FileChannel fc = FileChannel.open(Paths.get(lock.getAbsolutePath()), |
| StandardOpenOption.CREATE_NEW, StandardOpenOption.APPEND, |
| StandardOpenOption.WRITE); |
| try { |
| if (fc.tryLock() != null) { |
| System.out.println("locked: " + lock); |
| handler2 = createFileHandler(writableDir); |
| System.out.println("handler created: " + handler2); |
| after = listLocks(writableDir, true); |
| System.out.println("after creating handler: " + after.size() |
| + " locks found"); |
| after.removeAll(before); |
| if (after.size() != 1) { |
| throw new RuntimeException("Unexpected lock files found: " + after |
| + "\n\t" + lock + " should not have been reused"); |
| } |
| } else { |
| throw new RuntimeException("Failed to lock: " + lock); |
| } |
| } finally { |
| delete(lock); |
| } |
| } |
| } finally { |
| List<File> finalLocks = listLocks(writableDir, false); |
| System.out.println("end: " + finalLocks.size() + " locks found"); |
| delete(writableDir); |
| } |
| } |
| |
| |
| private static void testFileHandlerCreate(File writableDir, boolean first) |
| throws IOException { |
| List<File> before = listLocks(writableDir, true); |
| System.out.println("before: " + before.size() + " locks found"); |
| try { |
| if (first && !before.isEmpty()) { |
| throw new RuntimeException("Expected no lock file! Found: " + before); |
| } else if (!first && before.size() != 1) { |
| throw new RuntimeException("Expected a single lock file! Found: " + before); |
| } |
| } finally { |
| before.stream().forEach(CheckZombieLockTest::delete); |
| } |
| FileHandler handler = createFileHandler(writableDir); |
| System.out.println("handler created: " + handler); |
| List<File> after = listLocks(writableDir, true); |
| System.out.println("after creating handler: " + after.size() + " locks found"); |
| if (after.size() != 1) { |
| throw new RuntimeException("Unexpected number of lock files found for " |
| + handler + ": " + after); |
| } |
| } |
| |
| |
| /** |
| * Setup all the files and directories needed for the tests |
| * |
| * @return writable directory created that needs to be deleted when done |
| * @throws RuntimeException |
| */ |
| private static File setup() throws RuntimeException { |
| // First do some setup in the temporary directory (using same logic as |
| // FileHandler for %t pattern) |
| String tmpDir = System.getProperty("java.io.tmpdir"); // i.e. %t |
| if (tmpDir == null) { |
| tmpDir = System.getProperty("user.home"); |
| } |
| File tmpOrHomeDir = new File(tmpDir); |
| // Create a writable directory here (%t/writable-lockfile-dir) |
| File writableDir = new File(tmpOrHomeDir, WRITABLE_DIR); |
| if (!createFile(writableDir, true)) { |
| throw new RuntimeException("Test setup failed: unable to create" |
| + " writable working directory " |
| + writableDir.getAbsolutePath() ); |
| } |
| |
| // try to determine whether file locking is supported |
| final String uniqueFileName = UUID.randomUUID().toString()+".lck"; |
| try { |
| FileChannel fc = FileChannel.open(Paths.get(writableDir.getAbsolutePath(), |
| uniqueFileName), |
| StandardOpenOption.CREATE_NEW, StandardOpenOption.APPEND, |
| StandardOpenOption.DELETE_ON_CLOSE); |
| try { |
| fc.tryLock(); |
| } catch(IOException x) { |
| supportsLocking = false; |
| } finally { |
| fc.close(); |
| } |
| } catch (IOException t) { |
| // should not happen |
| System.err.println("Failed to create new file " + uniqueFileName + |
| " in " + writableDir.getAbsolutePath()); |
| throw new RuntimeException("Test setup failed: unable to run test", t); |
| } |
| return writableDir; |
| } |
| |
| /** |
| * @param newFile |
| * @return true if file already exists or creation succeeded |
| */ |
| private static boolean createFile(File newFile, boolean makeDirectory) { |
| if (newFile.exists()) { |
| return true; |
| } |
| if (makeDirectory) { |
| return newFile.mkdir(); |
| } else { |
| try { |
| return newFile.createNewFile(); |
| } catch (IOException ioex) { |
| ioex.printStackTrace(); |
| return false; |
| } |
| } |
| } |
| |
| /* |
| * Recursively delete all files starting at specified file |
| */ |
| private static void delete(File f) { |
| if (f != null && f.isDirectory()) { |
| for (File c : f.listFiles()) |
| delete(c); |
| } |
| if (!f.delete()) |
| System.err.println( |
| "WARNING: unable to delete/cleanup writable test directory: " |
| + f ); |
| } |
| } |