src/jalview/io/BackupFiles.java

   1 package jalview.io;
   2
   3 import jalview.bin.Cache;
   4 import jalview.gui.Desktop;
   5 import jalview.gui.JvOptionPane;
   6 import jalview.util.MessageManager;
   7
   8 import java.io.File;
   9 import java.io.IOException;
  10 import java.text.SimpleDateFormat;
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.Map;
  14 import java.util.TreeMap;
  15
  16 /*
  17  * BackupFiles used for manipulating (naming rolling/deleting) backup/version files when an alignment or project file is saved.
  18  * User configurable options are:
  19  * BACKUPFILES_ENABLED - boolean flag as to whether to use this mechanism or act as before, including overwriting files as saved.
  20  * BACKUPFILES_SUFFIX - a template to insert after the file extension.  Use '%n' to be replaced by a 0-led SUFFIX_DIGITS long integer.
  21  * BACKUPFILES_NO_MAX - flag to turn off setting a maximum number of backup files to keep.
  22  * BACKUPFILES_ROLL_MAX - the maximum number of backupfiles to keep for any one alignment or project file.
  23  * BACKUPFILES_SUFFIX_DIGITS - the number of digits to insert replace %n with (e.g. BACKUPFILES_SUFFIX_DIGITS = 3 would make "001", "002", etc)
  24  * BACKUPFILES_REVERSE_ORDER - if true then "logfile" style numbering and file rolling will occur. If false then ever-increasing version numbering will occur, but old files will still be deleted if there are more than ROLL_MAX backup files.
  25  * BACKUPFILES_CONFIRM_DELETE_OLD - if true then prompt/confirm with the user when deleting older backup/version files.
  26  */
  27
  28 public class BackupFiles
  29 {
  30
  31   // labels for saved params in Cache and .jalview_properties
  32   public static final String NS = "BACKUPFILES";
  33
  34   public static final String ENABLED = NS + "_ENABLED";
  35
  36   public static final String SUFFIX = NS + "_SUFFIX";
  37
  38   public static final String NO_MAX = NS + "_NO_MAX";
  39
  40   public static final String ROLL_MAX = NS + "_ROLL_MAX";
  41
  42   public static final String SUFFIX_DIGITS = NS + "_SUFFIX_DIGITS";
  43
  44   public static final String NUM_PLACEHOLDER = "%n";
  45
  46   public static final String REVERSE_ORDER = NS + "_REVERSE_ORDER";
  47
  48   public static final String CONFIRM_DELETE_OLD = NS
  49           + "_CONFIRM_DELETE_OLD";
  50
  51   private static final String DEFAULT_TEMP_FILE = "jalview_temp_file_" + NS;
  52
  53   private static final String TEMP_FILE_EXT = ".tmp";
  54
  55   // file - File object to be backed up and then updated (written over)
  56   private File file;
  57
  58   // enabled - default flag as to whether to do the backup file roll (if not
  59   // defined in preferences)
  60   private static boolean enabled;
  61
  62   // confirmDelete - default flag as to whether to confirm with the user before
  63   // deleting old backup/version files
  64   private static boolean confirmDelete;
  65
  66   // defaultSuffix - default template to use to append to basename of file
  67   private String suffix;
  68
  69   // noMax - flag to turn off a maximum number of files
  70   private boolean noMax;
  71
  72   // defaultMax - default max number of backup files
  73   private int max;
  74
  75   // defaultDigits - number of zero-led digits to use in the filename
  76   private int digits;
  77
  78   // reverseOrder - set to true to make newest (latest) files lowest number
  79   // (like rolled log files)
  80   private boolean reverseOrder;
  81
  82   // temp saved file to become new saved file
  83   private File tempFile;
  84
  85   // flag set to see if file save to temp file was successful
  86   private boolean tempFileWriteSuccess;
  87
  88   // array of files to be deleted, with extra information
  89   private ArrayList<DeleteFile> deleteFiles = new ArrayList<>();
  90
  91   // next backup filename
  92   private File nextBackupFile;
  93
  94   // date formatting for modification times
  95   private static final SimpleDateFormat sdf = new SimpleDateFormat(
  96           "yyyy-MM-dd HH:mm:ss");
  97
  98   public BackupFiles(String filename)
  99   {
 100     this(new File(filename));
 101   }
 102
 103   // first time defaults for SUFFIX, NO_MAX, ROLL_MAX, SUFFIX_DIGITS and
 104   // REVERSE_ORDER
 105   public BackupFiles(File file)
 106   {
 107     this(file, ".bak" + NUM_PLACEHOLDER, false, 3, 3, false);
 108   }
 109
 110   public BackupFiles(File file, String defaultSuffix, boolean defaultNoMax,
 111           int defaultMax, int defaultDigits, boolean defaultReverseOrder)
 112   {
 113     classInit();
 114     this.file = file;
 115     this.suffix = Cache.getDefault(SUFFIX, defaultSuffix);
 116     this.noMax = Cache.getDefault(NO_MAX, defaultNoMax);
 117     this.max = Cache.getDefault(ROLL_MAX, defaultMax);
 118     this.digits = Cache.getDefault(SUFFIX_DIGITS, defaultDigits);
 119     this.reverseOrder = Cache.getDefault(REVERSE_ORDER,
 120             defaultReverseOrder);
 121
 122     // create a temp file to save new data in
 123     File temp = null;
 124     try
 125     {
 126       if (file != null)
 127       {
 128         String tempfilename = file.getName();
 129         File tempdir = file.getParentFile();
 130         temp = File.createTempFile(tempfilename, TEMP_FILE_EXT, tempdir);
 131       }
 132       else
 133       {
 134         temp = File.createTempFile(DEFAULT_TEMP_FILE, TEMP_FILE_EXT);
 135       }
 136     } catch (IOException e)
 137     {
 138       System.out.println(
 139               "Could not create temp file to save into (IOException)");
 140     } catch (Exception e)
 141     {
 142       System.out.println("Exception ctreating temp file for saving");
 143     }
 144     this.setTempFile(temp);
 145   }
 146
 147   public static void classInit()
 148   {
 149     setEnabled(Cache.getDefault(ENABLED, true));
 150     setConfirmDelete(Cache.getDefault(CONFIRM_DELETE_OLD, true));
 151   }
 152
 153   public static void setEnabled(boolean flag)
 154   {
 155     enabled = flag;
 156   }
 157
 158   public static boolean getEnabled()
 159   {
 160     classInit();
 161     return enabled;
 162   }
 163
 164   public static void setConfirmDelete(boolean flag)
 165   {
 166     confirmDelete = flag;
 167   }
 168
 169   public static boolean getConfirmDelete()
 170   {
 171     classInit();
 172     return confirmDelete;
 173   }
 174
 175   // set, get and rename temp file into place
 176   public void setTempFile(File temp)
 177   {
 178     this.tempFile = temp;
 179   }
 180
 181   public File getTempFile()
 182   {
 183     return tempFile;
 184   }
 185
 186   public String getTempFilePath()
 187   {
 188     String path = null;
 189     try
 190     {
 191       path = this.getTempFile().getCanonicalPath();
 192     } catch (IOException e)
 193     {
 194       System.out.println(
 195               "IOException when getting Canonical Path of temp file '"
 196                       + this.getTempFile().getName() + "'");
 197     }
 198     return path;
 199   }
 200
 201   public boolean setWriteSuccess(boolean flag)
 202   {
 203     boolean old = this.tempFileWriteSuccess;
 204     this.tempFileWriteSuccess = flag;
 205     return old;
 206   }
 207
 208   public boolean getWriteSuccess()
 209   {
 210     return this.tempFileWriteSuccess;
 211   }
 212
 213   public boolean renameTempFile()
 214   {
 215     return tempFile.renameTo(file);
 216   }
 217
 218   // roll the backupfiles
 219   public boolean rollBackupFiles()
 220   {
 221     return this.rollBackupFiles(true);
 222   }
 223
 224   public boolean rollBackupFiles(boolean tidyUp)
 225   {
 226     // file doesn't yet exist or backups are not enabled or template is null or
 227     // empty
 228     if ((!file.exists()) || (!enabled) || max < 0 || suffix == null
 229             || suffix.length() == 0)
 230     {
 231       // nothing to do
 232       return true;
 233     }
 234
 235     String dir = "";
 236     File dirFile;
 237     try
 238     {
 239       dirFile = file.getParentFile();
 240       dir = dirFile.getCanonicalPath();
 241     } catch (Exception e)
 242     {
 243       System.out.println(
 244               "Could not get canonical path for file '" + file + "'");
 245       return false;
 246     }
 247     String filename = file.getName();
 248     String basename = filename;
 249
 250     boolean ret = true;
 251     // Create/move backups up one
 252
 253     deleteFiles.clear();
 254     //File[] oldFilesToDelete = null;
 255     //File[] newerOldFilesToDelete = null; // put files with newer modification
 256                                          // timestamps in here to warn the user!
 257
 258     // find existing backup files
 259     BackupFilenameFilter bff = new BackupFilenameFilter(basename, suffix,
 260             digits);
 261     File[] backupFiles = dirFile.listFiles(bff);
 262     int nextIndexNum = 0;
 263
 264     if (backupFiles.length == 0)
 265     {
 266       // No other backup files. Just need to move existing file to backupfile_1
 267       nextIndexNum = 1;
 268     }
 269     else
 270     {
 271       TreeMap<Integer, File> bfTreeMap = sortBackupFilesAsTreeMap(
 272               backupFiles, basename);
 273       // bfTreeMap now a sorted list of <Integer index>,<File backupfile>
 274       // mappings
 275
 276       if (reverseOrder)
 277       {
 278         // backup style numbering
 279
 280         File lastfile = null;
 281         File lastfiletobedeleted = null;
 282         String lastfiletobedeletedoriginalname = null;
 283
 284         int tempMax = noMax ? -1 : max;
 285         // noMax == true means no limits
 286         // look for first "gap" in backupFiles
 287         // if tempMax is -1 at this stage just keep going until there's a gap,
 288         // then hopefully tempMax gets set to the right index (a positive
 289         // integer so the loop breaks)...
 290         // why do I feel a little uneasy about this loop?..
 291         for (int i = 1; tempMax < 0 || i <= max; i++)
 292         {
 293           if (!bfTreeMap.containsKey(i)) // first index without existent
 294                                          // backupfile
 295           {
 296             tempMax = i;
 297           }
 298         }
 299
 300         for (int n = tempMax; n > 0; n--)
 301         {
 302           String backupfilename = dir + File.separatorChar
 303                   + BackupFilenameParts.getBackupFilename(n, basename,
 304                           suffix, digits);
 305           File backupfile_n = new File(backupfilename);
 306
 307           if (!backupfile_n.exists())
 308           {
 309             // no "oldest" file to delete
 310             lastfile = backupfile_n;
 311             lastfiletobedeleted = null;
 312             continue;
 313           }
 314
 315           // check the modification time of the previous file if it's going to
 316           // be deleted
 317           if (lastfiletobedeleted != null)
 318           {
 319             long oldLMT = lastfiletobedeleted.lastModified();
 320             long newLMT = backupfile_n.lastModified();
 321             if (oldLMT > newLMT)
 322             {
 323               String oldLMTString = sdf
 324                       .format(lastfiletobedeleted.lastModified());
 325               String newLMTString = sdf.format(backupfile_n.lastModified());
 326               System.out.println("WARNING! I am set to delete backupfile "
 327                       + lastfiletobedeleted.getName() + " (was '"
 328                       + lastfiletobedeletedoriginalname + "')"
 329                       + " has modification time "
 330                       + oldLMTString
 331                       + " which is newer than its replacement "
 332                       + backupfile_n.getName() + " with modification time "
 333                       + newLMTString);
 334
 335               addDeleteFile(lastfiletobedeleted, backupfile_n, true, true,
 336                       " (" + MessageManager.formatMessage(
 337                               "label.was_previous", new String[]
 338                               { backupfile_n.getName() }) + ")");
 339             }
 340
 341             // reset
 342             lastfiletobedeleted = null;
 343             lastfiletobedeletedoriginalname = null;
 344           }
 345
 346           if (!noMax && n == tempMax && backupfile_n.exists())
 347           {
 348             // move the largest (max) rolled file to a temp file and add to the
 349             // delete list
 350             try
 351             {
 352               File temp = File.createTempFile(backupfilename, TEMP_FILE_EXT,
 353                       dirFile);
 354               backupfile_n.renameTo(temp);
 355
 356               String message = "(" + MessageManager
 357                       .formatMessage("label.was_previous", new String[]
 358                       { backupfile_n.getName() }) + ")";
 359               addDeleteFile(temp, backupfile_n, true, false, message);
 360
 361               lastfiletobedeleted = temp;
 362             } catch (IOException e)
 363             {
 364               System.out.println(
 365                       "IOException when creating temporary file for backupfilename");
 366             }
 367           }
 368           else
 369           {
 370             // Just In Case
 371             if (lastfile != null)
 372             {
 373               ret = ret && backupfile_n.renameTo(lastfile);
 374             }
 375           }
 376
 377           lastfile = backupfile_n;
 378         }
 379
 380         // index to use for the latest backup
 381         nextIndexNum = 1;
 382       }
 383       else
 384       {
 385         // version style numbering (with earliest file deletion if max files
 386         // reached)
 387
 388         bfTreeMap.values().toArray(backupFiles);
 389
 390         // noMax == true means keep all backup files
 391         if ((!noMax) && bfTreeMap.size() >= max)
 392         {
 393           // need to delete some files to keep number of backups to designated
 394           // max
 395           int numToDelete = bfTreeMap.size() - max + 1;
 396           for (int i = 0; i < numToDelete; i++)
 397           {
 398             addDeleteFile(backupFiles[i], null, true, false, null);
 399           }
 400
 401         }
 402
 403         nextIndexNum = bfTreeMap.lastKey() + 1;
 404
 405       }
 406     }
 407
 408     // Let's make the new backup file!! yay, got there at last!
 409     String latestBackupFilename = dir + File.separatorChar
 410             + BackupFilenameParts.getBackupFilename(nextIndexNum, basename,
 411                     suffix, digits);
 412     nextBackupFile = new File(latestBackupFilename);
 413     ret |= file.renameTo(nextBackupFile);
 414
 415     if (tidyUp)
 416     {
 417       tidyUpFiles();
 418     }
 419
 420     return ret;
 421   }
 422
 423   private void tidyUpFiles()
 424   {
 425     deleteOldFiles();
 426   }
 427
 428   private void deleteOldFiles()
 429   {
 430     if (deleteFiles != null && !deleteFiles.isEmpty())
 431     {
 432       boolean confirm = confirmDelete;
 433       // delete old backup/version files
 434
 435       // check for newer files
 436       boolean newerDelete = hasNewerDeleteFile();
 437       StringBuilder newerDeleteSB = null;
 438       if (newerDelete)
 439       {
 440         newerDeleteSB = new StringBuilder();
 441         for (int i = 0; i < deleteFiles.size(); i++)
 442         {
 443           DeleteFile df = deleteFiles.get(i);
 444           if (df.newer && df.delete)
 445           {
 446             String oldName = df.oldFile.getName();
 447             String oldLMT = sdf.format(df.oldFile.lastModified());
 448             String newLMT = sdf.format(df.newFile.lastModified());
 449             if (newerDeleteSB.length() > 0)
 450             {
 451               newerDeleteSB.append("\n");
 452             }
 453             newerDeleteSB.append(
 454                     MessageManager.formatMessage("label.newerdelete_line",
 455                             new String[]
 456                             { oldName, oldLMT, df.newFile.getName(),
 457                                 newLMT })
 458             );
 459             if (df.info != null
 460                   && df.info.length() > 0)
 461             {
 462               newerDeleteSB.append(" ");
 463               newerDeleteSB.append(df.info);
 464             }
 465             confirm = true;
 466           }
 467         }
 468       }
 469
 470       boolean doDelete = false;
 471       StringBuilder deleteSB = null;
 472       if (confirmDelete && deleteFiles.size() > 0)
 473       {
 474         deleteSB = new StringBuilder();
 475         deleteSB.append(MessageManager
 476                 .getString("label.backupfiles_confirm_delete_old_files"));
 477         for (int i = 0; i < deleteFiles.size(); i++)
 478         {
 479           DeleteFile df = deleteFiles.get(i);
 480           if (!df.delete)
 481           {
 482             break;
 483           }
 484           deleteSB.append("\n");
 485           deleteSB.append(df.oldFile.getName());
 486           if (df.info != null
 487                 && df.info.length() > 0)
 488           {
 489             deleteSB.append("\n");
 490             deleteSB.append(df.info);
 491           }
 492         }
 493         confirm = true;
 494       }
 495
 496       if (confirm)
 497       {
 498         StringBuilder messageSB = new StringBuilder();
 499         if (deleteSB != null && deleteSB.length() > 0)
 500         {
 501           messageSB.append(deleteSB);
 502         }
 503         if (newerDeleteSB != null && newerDeleteSB.length() > 0)
 504         {
 505           messageSB.append("\n");
 506           messageSB.append(newerDeleteSB);
 507         }
 508
 509         int confirmButton = JvOptionPane.showConfirmDialog(Desktop.desktop,
 510                 messageSB.toString(),
 511                 MessageManager
 512                         .getString("label.backupfiles_confirm_delete"),
 513                 JvOptionPane.YES_NO_OPTION, JvOptionPane.WARNING_MESSAGE);
 514
 515         doDelete = (confirmButton == JvOptionPane.YES_OPTION);
 516       }
 517       else
 518       {
 519         doDelete = true;
 520       }
 521
 522       if (doDelete)
 523       {
 524         for (int i = 0; i < deleteFiles.size(); i++)
 525         {
 526           File fileToDelete = deleteFiles.get(i).oldFile;
 527           fileToDelete.delete();
 528           // System.out.println("DELETING '" + fileToDelete.getName() +
 529           // "'");
 530         }
 531       }
 532
 533     }
 534
 535     deleteFiles.clear();
 536   }
 537
 538   private TreeMap<Integer, File> sortBackupFilesAsTreeMap(
 539           File[] backupFiles,
 540           String basename)
 541   {
 542     // sort the backup files (based on integer found in the suffix) using a
 543     // precomputed Hashmap for speed
 544     Map<Integer, File> bfHashMap = new HashMap<>();
 545     for (int i = 0; i < backupFiles.length; i++)
 546     {
 547       File f = backupFiles[i];
 548       BackupFilenameParts bfp = new BackupFilenameParts(f, basename, suffix,
 549               digits);
 550       bfHashMap.put(bfp.indexNum(), f);
 551     }
 552     TreeMap<Integer, File> bfTreeMap = new TreeMap<>();
 553     bfTreeMap.putAll(bfHashMap);
 554     return bfTreeMap;
 555   }
 556
 557   public boolean rollBackupsAndRenameTempFile()
 558   {
 559     boolean write = this.getWriteSuccess();
 560
 561     boolean roll = false;
 562     boolean rename = false;
 563     if (write)
 564     {
 565       roll = this.rollBackupFiles(false);
 566       rename = this.renameTempFile();
 567     }
 568
 569     /*
 570      * Not sure that this confirmation is desirable.  By this stage the new file is
 571      * already written successfully, but something (e.g. disk full) has happened while
 572      * trying to roll the backup files, and most likely the filename needed will already
 573      * be vacant so renaming the temp file is nearly always correct!
 574      */
 575     boolean okay = roll && rename;
 576     if (!okay)
 577     {
 578       StringBuilder messageSB = new StringBuilder();
 579       messageSB.append(MessageManager.getString( "label.backupfiles_confirm_save_file_backupfiles_roll_wrong"));
 580       if (rename)
 581       {
 582         if (messageSB.length() > 0)
 583         {
 584           messageSB.append("\n");
 585         }
 586         messageSB.append(MessageManager.getString(
 587                 "label.backupfiles_confirm_save_new_saved_file_ok"));
 588       }
 589       else
 590       {
 591         if (messageSB.length() > 0)
 592         {
 593           messageSB.append("\n");
 594         }
 595         messageSB.append(MessageManager.getString(
 596                 "label.backupfiles_confirm_save_new_saved_file_not_ok"));
 597       }
 598
 599       int confirmButton = JvOptionPane.showConfirmDialog(Desktop.desktop,
 600               messageSB.toString(),
 601               MessageManager
 602                       .getString("label.backupfiles_confirm_save_file"),
 603               JvOptionPane.OK_OPTION, JvOptionPane.WARNING_MESSAGE);
 604       okay = confirmButton == JvOptionPane.OK_OPTION;
 605     }
 606     if (okay)
 607     {
 608       tidyUpFiles();
 609     }
 610
 611     return rename;
 612   }
 613
 614   public static TreeMap<Integer, File> getBackupFilesAsTreeMap(
 615           String fileName, String suffix, int digits)
 616   {
 617     File[] backupFiles = null;
 618
 619     File file = new File(fileName);
 620
 621     File dirFile;
 622     try
 623     {
 624       dirFile = file.getParentFile();
 625     } catch (Exception e)
 626     {
 627       System.out.println(
 628               "Could not get canonical path for file '" + file + "'");
 629       return new TreeMap<>();
 630     }
 631
 632     String filename = file.getName();
 633     String basename = filename;
 634
 635     // find existing backup files
 636     BackupFilenameFilter bff = new BackupFilenameFilter(basename, suffix,
 637             digits);
 638     backupFiles = dirFile.listFiles(bff); // is clone needed?
 639
 640     // sort the backup files (based on integer found in the suffix) using a
 641     // precomputed Hashmap for speed
 642     Map<Integer, File> bfHashMap = new HashMap<>();
 643     for (int i = 0; i < backupFiles.length; i++)
 644     {
 645       File f = backupFiles[i];
 646       BackupFilenameParts bfp = new BackupFilenameParts(f, basename, suffix,
 647               digits);
 648       bfHashMap.put(bfp.indexNum(), f);
 649     }
 650     TreeMap<Integer, File> bfTreeMap = new TreeMap<>();
 651     bfTreeMap.putAll(bfHashMap);
 652
 653     return bfTreeMap;
 654   }
 655
 656   private boolean addDeleteFile(File oldFile, File newFile, boolean delete,
 657           boolean newer, String info)
 658   {
 659     boolean ret = false;
 660     int pos = deleteFiles.indexOf(oldFile);
 661     if (pos > -1)
 662     {
 663       DeleteFile df = deleteFiles.get(pos);
 664       if (newFile != null)
 665       {
 666         df.newFile = newFile;
 667       }
 668       df.delete |= delete;
 669       df.newer |= newer;
 670       df.info += ';' + info;
 671       ret = true;
 672     }
 673     else
 674     {
 675       deleteFiles
 676               .add(new DeleteFile(oldFile, newFile, delete, newer, info));
 677     }
 678     return ret;
 679   }
 680
 681   private boolean hasNewerDeleteFile()
 682   {
 683     for (int i = 0; i < deleteFiles.size(); i++)
 684     {
 685       DeleteFile df = deleteFiles.get(i);
 686       if (df.newer)
 687       {
 688         return true;
 689       }
 690     }
 691     return false;
 692   }
 693 }
 694
 695 class DeleteFile
 696 {
 697   protected File oldFile;
 698
 699   protected File newFile;
 700
 701   protected boolean delete;
 702
 703   protected boolean newer;
 704
 705   protected String info;
 706
 707   protected DeleteFile(File oldFile, File newFile, boolean delete,
 708           boolean newer, String info)
 709   {
 710     this.oldFile = oldFile;
 711     this.newFile = newFile;
 712     this.delete = delete;
 713     this.newer = newer;
 714     this.info = info;
 715   }
 716
 717   public boolean equals(File file)
 718   {
 719     return this.oldFile.equals(file);
 720   }
 721 }