X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fio%2FBackupFiles.java;h=c697a993d26f9ff6f08610ca61ee24afe5b05abe;hb=9c19686c86fc6060c8734478ea6e73954684a597;hp=aafe8f29de6eac2fc3b40da1c11d7f6fcfa507f3;hpb=c860648463c56ba9f75e9d239e2f56edea8e31e7;p=jalview.git diff --git a/src/jalview/io/BackupFiles.java b/src/jalview/io/BackupFiles.java index aafe8f2..c697a99 100644 --- a/src/jalview/io/BackupFiles.java +++ b/src/jalview/io/BackupFiles.java @@ -4,12 +4,14 @@ import jalview.bin.Cache; import jalview.gui.Desktop; import jalview.gui.JvOptionPane; import jalview.util.MessageManager; +import jalview.util.Platform; import java.io.File; import java.io.IOException; -import java.util.Arrays; -import java.util.Map; +import java.text.SimpleDateFormat; +import java.util.ArrayList; import java.util.HashMap; +import java.util.Map; import java.util.TreeMap; /* @@ -44,7 +46,8 @@ public class BackupFiles public static final String REVERSE_ORDER = NS + "_REVERSE_ORDER"; - public static final String CONFIRM_DELETE_OLD = NS + "_CONFIRM_DELETE_OLD"; + public static final String CONFIRM_DELETE_OLD = NS + + "_CONFIRM_DELETE_OLD"; private static final String DEFAULT_TEMP_FILE = "jalview_temp_file_" + NS; @@ -83,6 +86,13 @@ public class BackupFiles // flag set to see if file save to temp file was successful private boolean tempFileWriteSuccess; + // array of files to be deleted, with extra information + private ArrayList deleteFiles = new ArrayList<>(); + + // date formatting for modification times + private static final SimpleDateFormat sdf = new SimpleDateFormat( + "yyyy-MM-dd HH:mm:ss"); + public BackupFiles(String filename) { this(new File(filename)); @@ -92,13 +102,11 @@ public class BackupFiles // REVERSE_ORDER public BackupFiles(File file) { - this(file, ".v" + NUM_PLACEHOLDER, false, 4, 3, false); + this(file, ".bak" + NUM_PLACEHOLDER, false, 3, 3, false); } - public BackupFiles(File file, - String defaultSuffix, boolean defaultNoMax, int defaultMax, - int defaultDigits, - boolean defaultReverseOrder) + public BackupFiles(File file, String defaultSuffix, boolean defaultNoMax, + int defaultMax, int defaultDigits, boolean defaultReverseOrder) { classInit(); this.file = file; @@ -117,7 +125,8 @@ public class BackupFiles { String tempfilename = file.getName(); File tempdir = file.getParentFile(); - temp = File.createTempFile(tempfilename, TEMP_FILE_EXT, tempdir); + temp = File.createTempFile(tempfilename, TEMP_FILE_EXT + "_newfile", + tempdir); } else { @@ -136,7 +145,7 @@ public class BackupFiles public static void classInit() { - setEnabled(Cache.getDefault(ENABLED, true)); + setEnabled(Cache.getDefault(ENABLED, !Platform.isJS())); setConfirmDelete(Cache.getDefault(CONFIRM_DELETE_OLD, true)); } @@ -205,20 +214,23 @@ public class BackupFiles return tempFile.renameTo(file); } - // roll the backupfiles public boolean rollBackupFiles() { + return this.rollBackupFiles(true); + } - // file doesn't yet exist or backups are not enabled - if ((!file.exists()) || (!enabled) || (max < 0)) + public boolean rollBackupFiles(boolean tidyUp) + { + // file doesn't yet exist or backups are not enabled or template is null or + // empty + if ((!file.exists()) || (!enabled) || max < 0 || suffix == null + || suffix.length() == 0) { // nothing to do return true; } - // split filename up to insert suffix template in the right place. template - // and backupMax can be set in .jalview_properties String dir = ""; File dirFile; try @@ -237,15 +249,14 @@ public class BackupFiles boolean ret = true; // Create/move backups up one - File[] oldFilesToDelete = null; - + deleteFiles.clear(); + // find existing backup files BackupFilenameFilter bff = new BackupFilenameFilter(basename, suffix, digits); File[] backupFiles = dirFile.listFiles(bff); int nextIndexNum = 0; - String confirmDeleteExtraInfo = null; - + if (backupFiles.length == 0) { // No other backup files. Just need to move existing file to backupfile_1 @@ -253,13 +264,16 @@ public class BackupFiles } else { - TreeMap bfTreeMap = sortBackupFilesAsTreeMap(backupFiles, basename); + TreeMap bfTreeMap = sortBackupFilesAsTreeMap( + backupFiles, basename); + // bfTreeMap now a sorted list of , + // mappings if (reverseOrder) { // backup style numbering - File lastfile = null; + int tempMax = noMax ? -1 : max; // noMax == true means no limits // look for first "gap" in backupFiles @@ -275,51 +289,96 @@ public class BackupFiles tempMax = i; } } - - // for (int m = 0; m < tempMax; m++) + + File previousFile = null; + File fileToBeDeleted = null; for (int n = tempMax; n > 0; n--) { - // int n = tempMax - m; String backupfilename = dir + File.separatorChar - + BackupFilenameFilter.getBackupFilename(n, basename, + + BackupFilenameParts.getBackupFilename(n, basename, suffix, digits); File backupfile_n = new File(backupfilename); if (!backupfile_n.exists()) { - lastfile = backupfile_n; + // no "oldest" file to delete + previousFile = backupfile_n; + fileToBeDeleted = null; continue; } - // if (m == 0 && backupfile_n.exists()) - if ((!noMax) && n == tempMax && backupfile_n.exists()) + // check the modification time of this (backupfile_n) and the previous + // file (fileToBeDeleted) if the previous file is going to be deleted + if (fileToBeDeleted != null) { - // move the largest (max) rolled file to a temp file and add to the delete list + File replacementFile = backupfile_n; + long fileToBeDeletedLMT = fileToBeDeleted.lastModified(); + long replacementFileLMT = replacementFile.lastModified(); + try { - File temp = File.createTempFile(backupfilename, TEMP_FILE_EXT, - dirFile); - backupfile_n.renameTo(temp); - - oldFilesToDelete = new File[] { temp }; - confirmDeleteExtraInfo = "(was " + backupfile_n.getName() - + ")"; - } catch (IOException e) + File oldestTempFile = nextTempFile(fileToBeDeleted.getName(), + dirFile); + + if (fileToBeDeletedLMT > replacementFileLMT) + { + String fileToBeDeletedLMTString = sdf + .format(fileToBeDeletedLMT); + String replacementFileLMTString = sdf + .format(replacementFileLMT); + System.out.println("WARNING! I am set to delete backupfile " + + fileToBeDeleted.getName() + + " has modification time " + + fileToBeDeletedLMTString + + " which is newer than its replacement " + + replacementFile.getName() + + " with modification time " + + replacementFileLMTString); + + boolean delete = confirmNewerDeleteFile(fileToBeDeleted, + replacementFile, true); + + if (delete) + { + // User has confirmed delete -- no need to add it to the list + fileToBeDeleted.delete(); + } + else + { + fileToBeDeleted.renameTo(oldestTempFile); + } + } + else + { + fileToBeDeleted.renameTo(oldestTempFile); + addDeleteFile(oldestTempFile); + } + + } catch (Exception e) { System.out.println( - "IOException when creating temporary file for backupfilename"); + "Error occurred, probably making new temp file for '" + + fileToBeDeleted.getName() + "'"); + e.printStackTrace(); } + + // reset + fileToBeDeleted = null; + } + + if (!noMax && n == tempMax && backupfile_n.exists()) + { + fileToBeDeleted = backupfile_n; } else { - // Just In Case - if (lastfile != null) + if (previousFile != null) { - ret = ret && backupfile_n.renameTo(lastfile); + ret = ret && backupfile_n.renameTo(previousFile); } } - lastfile = backupfile_n; + previousFile = backupfile_n; } // index to use for the latest backup @@ -330,7 +389,6 @@ public class BackupFiles // version style numbering (with earliest file deletion if max files // reached) - bfTreeMap.values().toArray(backupFiles); // noMax == true means keep all backup files @@ -339,147 +397,318 @@ public class BackupFiles // need to delete some files to keep number of backups to designated // max int numToDelete = bfTreeMap.size() - max + 1; - oldFilesToDelete = Arrays.copyOfRange(backupFiles, 0, - numToDelete); + // the "replacement" file is the latest backup file being kept (it's + // not replacing though) + File replacementFile = numToDelete < backupFiles.length + ? backupFiles[numToDelete] + : null; + for (int i = 0; i < numToDelete; i++) + { + // check the deletion files for modification time of the last + // backupfile being saved + File fileToBeDeleted = backupFiles[i]; + boolean delete = true; + + boolean newer = false; + if (replacementFile != null) + { + long fileToBeDeletedLMT = fileToBeDeleted.lastModified(); + long replacementFileLMT = replacementFile != null + ? replacementFile.lastModified() + : Long.MAX_VALUE; + if (fileToBeDeletedLMT > replacementFileLMT) + { + String fileToBeDeletedLMTString = sdf + .format(fileToBeDeletedLMT); + String replacementFileLMTString = sdf + .format(replacementFileLMT); + + System.out + .println("WARNING! I am set to delete backupfile '" + + fileToBeDeleted.getName() + + "' has modification time " + + fileToBeDeletedLMTString + + " which is newer than the oldest backupfile being kept '" + + replacementFile.getName() + + "' with modification time " + + replacementFileLMTString); + + delete = confirmNewerDeleteFile(fileToBeDeleted, + replacementFile, false); + if (delete) + { + // User has confirmed delete -- no need to add it to the list + fileToBeDeleted.delete(); + delete = false; + } + else + { + // keeping file, nothing to do! + } + } + } + if (delete) + { + addDeleteFile(fileToBeDeleted); + } + + } } nextIndexNum = bfTreeMap.lastKey() + 1; - } } - deleteOldFiles(oldFilesToDelete, confirmDeleteExtraInfo); - // Let's make the new backup file!! yay, got there at last! String latestBackupFilename = dir + File.separatorChar - + BackupFilenameFilter.getBackupFilename(nextIndexNum, basename, + + BackupFilenameParts.getBackupFilename(nextIndexNum, basename, suffix, digits); - File latestBackupFile = new File(latestBackupFilename); - ret = ret && file.renameTo(latestBackupFile); + ret |= file.renameTo(new File(latestBackupFilename)); + + if (tidyUp) + { + tidyUpFiles(); + } return ret; } - private void deleteOldFiles(File[] oldFilesToDelete, String confirmDeleteExtraInfo) { - if (oldFilesToDelete != null && oldFilesToDelete.length > 0) + private static File nextTempFile(String filename, File dirFile) + throws IOException + { + File temp = null; + COUNT: for (int i = 1; i < 1000; i++) + { + File trythis = new File(dirFile, + filename + '~' + Integer.toString(i)); + if (!trythis.exists()) + { + temp = trythis; + break COUNT; + } + + } + if (temp == null) { - // delete old backup/version files + temp = File.createTempFile(filename, TEMP_FILE_EXT, dirFile); + } + return temp; + } + + private void tidyUpFiles() + { + deleteOldFiles(); + } + + private static boolean confirmNewerDeleteFile(File fileToBeDeleted, + File replacementFile, boolean replace) + { + StringBuilder messageSB = new StringBuilder(); + + File ftbd = fileToBeDeleted; + String ftbdLMT = sdf.format(ftbd.lastModified()); + String ftbdSize = Long.toString(ftbd.length()); + + File rf = replacementFile; + String rfLMT = sdf.format(rf.lastModified()); + String rfSize = Long.toString(rf.length()); + + int confirmButton = JvOptionPane.NO_OPTION; + if (replace) + { + File saveFile = null; + try + { + saveFile = nextTempFile(ftbd.getName(), ftbd.getParentFile()); + } catch (Exception e) + { + System.out.println( + "Error when confirming to keep backup file newer than other backup files."); + e.printStackTrace(); + } + messageSB.append(MessageManager.formatMessage( + "label.newerdelete_replacement_line", new String[] + { ftbd.getName(), rf.getName(), ftbdLMT, rfLMT, ftbdSize, + rfSize })); + messageSB.append("\n\n"); + messageSB.append(MessageManager.formatMessage( + "label.confirm_deletion_or_rename", new String[] + { ftbd.getName(), saveFile.getName() })); + String[] options = new String[] { + MessageManager.getString("label.delete"), + MessageManager.getString("label.rename") }; + + confirmButton = JvOptionPane.showOptionDialog(Desktop.getDesktopPane(), + messageSB.toString(), + MessageManager.getString("label.backupfiles_confirm_delete"), + JvOptionPane.YES_NO_OPTION, JvOptionPane.WARNING_MESSAGE, + null, options, options[0]); + } + else + { + messageSB.append(MessageManager + .formatMessage("label.newerdelete_line", new String[] + { ftbd.getName(), rf.getName(), ftbdLMT, rfLMT, ftbdSize, + rfSize })); + messageSB.append("\n\n"); + messageSB.append(MessageManager + .formatMessage("label.confirm_deletion", new String[] + { ftbd.getName() })); + String[] options = new String[] { + MessageManager.getString("label.delete"), + MessageManager.getString("label.keep") }; + + confirmButton = JvOptionPane.showOptionDialog(Desktop.getDesktopPane(), + messageSB.toString(), + MessageManager.getString("label.backupfiles_confirm_delete"), + JvOptionPane.YES_NO_OPTION, JvOptionPane.WARNING_MESSAGE, + null, options, options[0]); + } + + + // return should be TRUE if file is to be deleted + return (confirmButton == JvOptionPane.YES_OPTION); + } - boolean delete = false; - if (confirmDelete) + private void deleteOldFiles() + { + if (deleteFiles != null && !deleteFiles.isEmpty()) + { + boolean doDelete = false; + StringBuilder messageSB = null; + if (confirmDelete && deleteFiles.size() > 0) { - // Object[] confirmMessageArray = {}; - StringBuilder confirmMessage = new StringBuilder(); - confirmMessage.append(MessageManager + messageSB = new StringBuilder(); + messageSB.append(MessageManager .getString("label.backupfiles_confirm_delete_old_files")); - for (File f : oldFilesToDelete) - { - confirmMessage.append("\n"); - confirmMessage.append(f.getName()); - } - if (confirmDeleteExtraInfo != null - && confirmDeleteExtraInfo.length() > 0) + for (int i = 0; i < deleteFiles.size(); i++) { - confirmMessage.append("\n"); - confirmMessage.append(confirmDeleteExtraInfo); + File df = deleteFiles.get(i); + messageSB.append("\n"); + messageSB.append(df.getName()); + messageSB.append(" "); + messageSB.append(MessageManager.formatMessage("label.file_info", + new String[] + { sdf.format(df.lastModified()), + Long.toString(df.length()) })); } - int confirm = JvOptionPane.showConfirmDialog(Desktop.desktop, - confirmMessage.toString(), + + int confirmButton = JvOptionPane.showConfirmDialog(Desktop.getDesktopPane(), + messageSB.toString(), MessageManager .getString("label.backupfiles_confirm_delete"), JvOptionPane.YES_NO_OPTION, JvOptionPane.WARNING_MESSAGE); - delete = (confirm == JvOptionPane.YES_OPTION); + doDelete = (confirmButton == JvOptionPane.YES_OPTION); } else { - delete = true; + doDelete = true; } - if (delete) + if (doDelete) { - for (int i = 0; i < oldFilesToDelete.length; i++) + for (int i = 0; i < deleteFiles.size(); i++) { - File fileToDelete = oldFilesToDelete[i]; + File fileToDelete = deleteFiles.get(i); fileToDelete.delete(); - // System.out.println("DELETING '" + fileToDelete.getName() + - // "'"); + System.out.println("DELETING '" + fileToDelete.getName() + "'"); } } } + + deleteFiles.clear(); } - private TreeMap sortBackupFilesAsTreeMap(File[] backupFiles, String basename) { - // sort the backup files (based on integer found in the suffix) using a - // precomputed Hashmap for speed - Map bfHashMap = new HashMap<>(); - for (int i = 0; i < backupFiles.length; i++) - { - File f = backupFiles[i]; - BackupFilenameParts bfp = new BackupFilenameParts(f, basename, suffix, digits); - bfHashMap.put(bfp.indexNum(), f); - } - TreeMap bfTreeMap = new TreeMap<>(); - bfTreeMap.putAll(bfHashMap); - return bfTreeMap; + private TreeMap sortBackupFilesAsTreeMap( + File[] backupFiles, + String basename) + { + // sort the backup files (based on integer found in the suffix) using a + // precomputed Hashmap for speed + Map bfHashMap = new HashMap<>(); + for (int i = 0; i < backupFiles.length; i++) + { + File f = backupFiles[i]; + BackupFilenameParts bfp = new BackupFilenameParts(f, basename, suffix, + digits); + bfHashMap.put(bfp.indexNum(), f); + } + TreeMap bfTreeMap = new TreeMap<>(); + bfTreeMap.putAll(bfHashMap); + return bfTreeMap; } public boolean rollBackupsAndRenameTempFile() { boolean write = this.getWriteSuccess(); - + boolean roll = false; - if (write) { - roll = this.rollBackupFiles(); - } else { - return false; + boolean rename = false; + if (write) + { + roll = this.rollBackupFiles(false); + rename = this.renameTempFile(); } - + /* * Not sure that this confirmation is desirable. By this stage the new file is * already written successfully, but something (e.g. disk full) has happened while * trying to roll the backup files, and most likely the filename needed will already * be vacant so renaming the temp file is nearly always correct! */ - if (!roll) + boolean okay = roll && rename; + if (!okay) { - int confirm = JvOptionPane.showConfirmDialog(Desktop.desktop, - MessageManager.getString( - "label.backupfiles_confirm_save_file_backupfiles_roll_wrong"), - MessageManager.getString("label.backupfiles_confirm_save_file"), - JvOptionPane.YES_NO_OPTION, JvOptionPane.WARNING_MESSAGE); - - if (confirm == JvOptionPane.YES_OPTION) + StringBuilder messageSB = new StringBuilder(); + messageSB.append(MessageManager.getString( "label.backupfiles_confirm_save_file_backupfiles_roll_wrong")); + if (rename) { - roll = true; + if (messageSB.length() > 0) + { + messageSB.append("\n"); + } + messageSB.append(MessageManager.getString( + "label.backupfiles_confirm_save_new_saved_file_ok")); + } + else + { + if (messageSB.length() > 0) + { + messageSB.append("\n"); + } + messageSB.append(MessageManager.getString( + "label.backupfiles_confirm_save_new_saved_file_not_ok")); } - } - boolean rename = false; - if (roll) + int confirmButton = JvOptionPane.showConfirmDialog(Desktop.getDesktopPane(), + messageSB.toString(), + MessageManager + .getString("label.backupfiles_confirm_save_file"), + JvOptionPane.OK_OPTION, JvOptionPane.WARNING_MESSAGE); + okay = confirmButton == JvOptionPane.OK_OPTION; + } + if (okay) { - rename = this.renameTempFile(); + tidyUpFiles(); } return rename; } public static TreeMap getBackupFilesAsTreeMap( - String fileName, - String suffix, int digits) + String fileName, String suffix, int digits) { File[] backupFiles = null; File file = new File(fileName); - String dir = ""; File dirFile; try { dirFile = file.getParentFile(); - dir = dirFile.getCanonicalPath(); } catch (Exception e) { System.out.println( @@ -489,11 +718,12 @@ public class BackupFiles String filename = file.getName(); String basename = filename; - + // find existing backup files - BackupFilenameFilter bff = new BackupFilenameFilter(basename, suffix, digits); + BackupFilenameFilter bff = new BackupFilenameFilter(basename, suffix, + digits); backupFiles = dirFile.listFiles(bff); // is clone needed? - + // sort the backup files (based on integer found in the suffix) using a // precomputed Hashmap for speed Map bfHashMap = new HashMap<>(); @@ -510,6 +740,26 @@ public class BackupFiles return bfTreeMap; } + /* + private boolean addDeleteFile(File fileToBeDeleted, File originalFile, + boolean delete, boolean newer) + { + return addDeleteFile(fileToBeDeleted, originalFile, null, delete, newer); + } + */ + private boolean addDeleteFile(File fileToBeDeleted) + { + boolean ret = false; + int pos = deleteFiles.indexOf(fileToBeDeleted); + if (pos > -1) + { + return true; + } + else + { + deleteFiles.add(fileToBeDeleted); + } + return ret; + } } -