001// License: GPL. For details, see LICENSE file. 002package org.openstreetmap.josm.gui.layer; 003 004import static org.openstreetmap.josm.tools.I18n.marktr; 005import static org.openstreetmap.josm.tools.I18n.tr; 006import static org.openstreetmap.josm.tools.Utils.getSystemProperty; 007 008import java.io.BufferedReader; 009import java.io.File; 010import java.io.FileFilter; 011import java.io.IOException; 012import java.lang.management.ManagementFactory; 013import java.nio.charset.StandardCharsets; 014import java.nio.file.Files; 015import java.nio.file.Path; 016import java.time.Instant; 017import java.util.ArrayList; 018import java.util.Arrays; 019import java.util.Collections; 020import java.util.Comparator; 021import java.util.Date; 022import java.util.Deque; 023import java.util.HashSet; 024import java.util.Iterator; 025import java.util.LinkedList; 026import java.util.List; 027import java.util.Locale; 028import java.util.Set; 029import java.util.Timer; 030import java.util.TimerTask; 031import java.util.concurrent.ExecutionException; 032import java.util.concurrent.Future; 033import java.util.concurrent.TimeUnit; 034import java.util.regex.Pattern; 035 036import org.openstreetmap.josm.actions.OpenFileAction.OpenFileTask; 037import org.openstreetmap.josm.data.Data; 038import org.openstreetmap.josm.data.osm.NoteData; 039import org.openstreetmap.josm.data.osm.NoteData.NoteDataUpdateListener; 040import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent; 041import org.openstreetmap.josm.data.osm.event.DataSetListenerAdapter; 042import org.openstreetmap.josm.data.osm.event.DataSetListenerAdapter.Listener; 043import org.openstreetmap.josm.data.preferences.BooleanProperty; 044import org.openstreetmap.josm.data.preferences.IntegerProperty; 045import org.openstreetmap.josm.gui.MainApplication; 046import org.openstreetmap.josm.gui.Notification; 047import org.openstreetmap.josm.gui.io.importexport.NoteImporter; 048import org.openstreetmap.josm.gui.io.importexport.OsmImporter; 049import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent; 050import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener; 051import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent; 052import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent; 053import org.openstreetmap.josm.gui.util.GuiHelper; 054import org.openstreetmap.josm.spi.preferences.Config; 055import org.openstreetmap.josm.tools.ImageProvider; 056import org.openstreetmap.josm.tools.Logging; 057import org.openstreetmap.josm.tools.Utils; 058 059/** 060 * Saves data and note layers periodically so they can be recovered in case of a crash. 061 * 062 * There are 2 directories 063 * - autosave dir: copies of the currently open data layers are saved here every 064 * PROP_INTERVAL seconds. When a data layer is closed normally, the corresponding 065 * files are removed. If this dir is non-empty on start, JOSM assumes 066 * that it crashed last time. 067 * - deleted layers dir: "secondary archive" - when autosaved layers are restored 068 * they are copied to this directory. We cannot keep them in the autosave folder, 069 * but just deleting it would be dangerous: Maybe a feature inside the file 070 * caused JOSM to crash. If the data is valuable, the user can still try to 071 * open with another versions of JOSM or fix the problem manually. 072 * 073 * The deleted layers dir keeps at most PROP_DELETED_LAYERS files. 074 * 075 * @since 3378 (creation) 076 * @since 10386 (new LayerChangeListener interface) 077 */ 078public class AutosaveTask extends TimerTask implements LayerChangeListener, Listener, NoteDataUpdateListener { 079 080 private static final char[] ILLEGAL_CHARACTERS = {'/', '\n', '\r', '\t', '\0', '\f', '`', '?', '*', '\\', '<', '>', '|', '\"', ':'}; 081 private static final String AUTOSAVE_DIR = "autosave"; 082 private static final String DELETED_LAYERS_DIR = "autosave/deleted_layers"; 083 084 /** 085 * If autosave is enabled 086 */ 087 public static final BooleanProperty PROP_AUTOSAVE_ENABLED = new BooleanProperty("autosave.enabled", true); 088 /** 089 * The number of files to store per layer 090 */ 091 public static final IntegerProperty PROP_FILES_PER_LAYER = new IntegerProperty("autosave.filesPerLayer", 1); 092 /** 093 * How many deleted layers should be stored 094 */ 095 public static final IntegerProperty PROP_DELETED_LAYERS = new IntegerProperty("autosave.deletedLayersBackupCount", 5); 096 /** 097 * The autosave interval, in seconds 098 */ 099 public static final IntegerProperty PROP_INTERVAL = new IntegerProperty("autosave.interval", (int) TimeUnit.MINUTES.toSeconds(5)); 100 /** 101 * The maximum number of autosave files to store 102 */ 103 public static final IntegerProperty PROP_INDEX_LIMIT = new IntegerProperty("autosave.index-limit", 1000); 104 /** 105 * Defines if a notification should be displayed after each autosave 106 */ 107 public static final BooleanProperty PROP_NOTIFICATION = new BooleanProperty("autosave.notification", false); 108 109 protected static final class AutosaveLayerInfo<T extends AbstractModifiableLayer> { 110 private final T layer; 111 private String layerName; 112 private String layerFileName; 113 private final Deque<File> backupFiles = new LinkedList<>(); 114 115 AutosaveLayerInfo(T layer) { 116 this.layer = layer; 117 } 118 } 119 120 private final DataSetListenerAdapter datasetAdapter = new DataSetListenerAdapter(this); 121 private final Set<Data> changedData = new HashSet<>(); 122 private final List<AutosaveLayerInfo<?>> layersInfo = new ArrayList<>(); 123 private final Object layersLock = new Object(); 124 private final Deque<File> deletedLayers = new LinkedList<>(); 125 126 private final File autosaveDir = new File(Config.getDirs().getUserDataDirectory(true), AUTOSAVE_DIR); 127 private final File deletedLayersDir = new File(Config.getDirs().getUserDataDirectory(true), DELETED_LAYERS_DIR); 128 129 /** 130 * Replies the autosave directory. 131 * @return the autosave directory 132 * @since 10299 133 */ 134 public final Path getAutosaveDir() { 135 return autosaveDir.toPath(); 136 } 137 138 /** 139 * Starts the autosave background task. 140 */ 141 public void schedule() { 142 if (PROP_INTERVAL.get() > 0) { 143 144 if (!autosaveDir.exists() && !autosaveDir.mkdirs()) { 145 Logging.warn(tr("Unable to create directory {0}, autosave will be disabled", autosaveDir.getAbsolutePath())); 146 return; 147 } 148 if (!deletedLayersDir.exists() && !deletedLayersDir.mkdirs()) { 149 Logging.warn(tr("Unable to create directory {0}, autosave will be disabled", deletedLayersDir.getAbsolutePath())); 150 return; 151 } 152 153 File[] files = deletedLayersDir.listFiles(); 154 if (files != null) { 155 try { 156 Arrays.sort(files, Comparator.comparingLong(File::lastModified)); 157 } catch (Exception e) { 158 Logging.error(e); 159 } 160 deletedLayers.addAll(Arrays.asList(files)); 161 } 162 163 new Timer(true).schedule(this, TimeUnit.SECONDS.toMillis(1), TimeUnit.SECONDS.toMillis(PROP_INTERVAL.get())); 164 MainApplication.getLayerManager().addAndFireLayerChangeListener(this); 165 } 166 } 167 168 private static String getFileName(String layerName, int index) { 169 String result = layerName; 170 for (char illegalCharacter : ILLEGAL_CHARACTERS) { 171 result = result.replaceAll(Pattern.quote(String.valueOf(illegalCharacter)), 172 '&' + String.valueOf((int) illegalCharacter) + ';'); 173 } 174 if (index != 0) { 175 result = result + '_' + index; 176 } 177 return result; 178 } 179 180 private void setLayerFileName(AutosaveLayerInfo<?> layer) { 181 int index = 0; 182 while (true) { 183 String filename = getFileName(layer.layer.getName(), index); 184 boolean foundTheSame = layersInfo.stream().anyMatch(info -> info != layer && filename.equals(info.layerFileName)); 185 if (!foundTheSame) { 186 layer.layerFileName = filename; 187 return; 188 } 189 190 index++; 191 } 192 } 193 194 protected File getNewLayerFile(AutosaveLayerInfo<?> layer, Instant now, int startIndex) { 195 int index = startIndex; 196 while (true) { 197 String filename = String.format(Locale.ENGLISH, "%1$s_%2$tY%2$tm%2$td_%2$tH%2$tM%2$tS%2$tL%3$s", 198 layer.layerFileName, Date.from(now), index == 0 ? "" : ('_' + Integer.toString(index))); 199 File result = new File(autosaveDir, filename + '.' + 200 (layer.layer instanceof NoteLayer ? 201 Config.getPref().get("autosave.notes.extension", "osn") : 202 Config.getPref().get("autosave.extension", "osm"))); 203 try { 204 if (index > PROP_INDEX_LIMIT.get()) 205 throw new IOException("index limit exceeded"); 206 if (result.createNewFile()) { 207 createNewPidFile(autosaveDir, filename); 208 return result; 209 } else { 210 Logging.warn(tr("Unable to create file {0}, other filename will be used", result.getAbsolutePath())); 211 } 212 } catch (IOException e) { 213 Logging.log(Logging.LEVEL_ERROR, tr("IOError while creating file, autosave will be skipped: {0}", e.getMessage()), e); 214 return null; 215 } 216 index++; 217 } 218 } 219 220 private static void createNewPidFile(File autosaveDir, String filename) { 221 File pidFile = new File(autosaveDir, filename+".pid"); 222 try { 223 final String content = ManagementFactory.getRuntimeMXBean().getName(); 224 Files.write(pidFile.toPath(), Collections.singleton(content), StandardCharsets.UTF_8); 225 } catch (IOException | SecurityException t) { 226 Logging.error(t); 227 } 228 } 229 230 private void savelayer(AutosaveLayerInfo<?> info) { 231 if (!info.layer.getName().equals(info.layerName)) { 232 setLayerFileName(info); 233 info.layerName = info.layer.getName(); 234 } 235 try { 236 Data data = info.layer.getData(); 237 if (data != null && changedData.remove(data)) { 238 File file = getNewLayerFile(info, Instant.now(), 0); 239 if (file != null) { 240 info.backupFiles.add(file); 241 info.layer.autosave(file); 242 } 243 } 244 } catch (IOException e) { 245 Logging.error(e); 246 } 247 while (info.backupFiles.size() > PROP_FILES_PER_LAYER.get()) { 248 File oldFile = info.backupFiles.remove(); 249 if (Utils.deleteFile(oldFile, marktr("Unable to delete old backup file {0}"))) { 250 Utils.deleteFile(getPidFile(oldFile), marktr("Unable to delete old backup file {0}")); 251 } 252 } 253 } 254 255 @Override 256 public void run() { 257 synchronized (layersLock) { 258 try { 259 for (AutosaveLayerInfo<?> info: layersInfo) { 260 savelayer(info); 261 } 262 changedData.clear(); 263 if (PROP_NOTIFICATION.get() && !layersInfo.isEmpty()) { 264 GuiHelper.runInEDT(this::displayNotification); 265 } 266 } catch (RuntimeException t) { 267 // Don't let exception stop time thread 268 Logging.error("Autosave failed:"); 269 Logging.error(t); 270 } 271 } 272 } 273 274 protected void displayNotification() { 275 new Notification(tr("Your work has been saved automatically.")) 276 .setIcon(ImageProvider.get("save")) 277 .setDuration(Notification.TIME_SHORT) 278 .show(); 279 } 280 281 @Override 282 public void layerOrderChanged(LayerOrderChangeEvent e) { 283 // Do nothing 284 } 285 286 private void registerNewlayer(OsmDataLayer layer) { 287 synchronized (layersLock) { 288 layer.getDataSet().addDataSetListener(datasetAdapter); 289 layersInfo.add(new AutosaveLayerInfo<>(layer)); 290 } 291 } 292 293 private void registerNewlayer(NoteLayer layer) { 294 synchronized (layersLock) { 295 layer.getNoteData().addNoteDataUpdateListener(this); 296 layersInfo.add(new AutosaveLayerInfo<>(layer)); 297 } 298 } 299 300 @Override 301 public void layerAdded(LayerAddEvent e) { 302 Layer layer = e.getAddedLayer(); 303 if (layer.isSavable()) { 304 if (layer instanceof OsmDataLayer) { 305 registerNewlayer((OsmDataLayer) layer); 306 } else if (layer instanceof NoteLayer) { 307 registerNewlayer((NoteLayer) layer); 308 } else if (layer instanceof AbstractModifiableLayer) { 309 synchronized (layersLock) { 310 layersInfo.add(new AutosaveLayerInfo<>((AbstractModifiableLayer) layer)); 311 } 312 } else { 313 Logging.debug("Unsupported savable layer type: {0}", layer.getClass().getSimpleName()); 314 } 315 } 316 } 317 318 @Override 319 public void layerRemoving(LayerRemoveEvent e) { 320 if (e.getRemovedLayer() instanceof OsmDataLayer) { 321 synchronized (layersLock) { 322 OsmDataLayer osmLayer = (OsmDataLayer) e.getRemovedLayer(); 323 osmLayer.getDataSet().removeDataSetListener(datasetAdapter); 324 cleanupLayer(osmLayer); 325 } 326 } else if (e.getRemovedLayer() instanceof NoteLayer) { 327 synchronized (layersLock) { 328 NoteLayer noteLayer = (NoteLayer) e.getRemovedLayer(); 329 noteLayer.getNoteData().removeNoteDataUpdateListener(this); 330 cleanupLayer(noteLayer); 331 } 332 } else if (e.getRemovedLayer() instanceof AbstractModifiableLayer) { 333 synchronized (layersLock) { 334 cleanupLayer((AbstractModifiableLayer) e.getRemovedLayer()); 335 } 336 } 337 } 338 339 private void cleanupLayer(AbstractModifiableLayer removedLayer) { 340 Iterator<AutosaveLayerInfo<?>> it = layersInfo.iterator(); 341 while (it.hasNext()) { 342 AutosaveLayerInfo<?> info = it.next(); 343 if (info.layer == removedLayer) { 344 345 savelayer(info); 346 File lastFile = info.backupFiles.pollLast(); 347 if (lastFile != null) { 348 moveToDeletedLayersFolder(lastFile); 349 } 350 for (File file: info.backupFiles) { 351 if (Utils.deleteFile(file)) { 352 Utils.deleteFile(getPidFile(file)); 353 } 354 } 355 356 it.remove(); 357 } 358 } 359 } 360 361 @Override 362 public void processDatasetEvent(AbstractDatasetChangedEvent event) { 363 dataUpdated(event.getDataset()); 364 } 365 366 @Override 367 public void noteDataUpdated(NoteData data) { 368 dataUpdated(data); 369 } 370 371 /** 372 * Indicate that data has changed, and it might be a good idea to autosave. 373 * 374 * @param data The data that has changed 375 * @return See {@link Set#add} 376 * @since 16548 377 */ 378 public boolean dataUpdated(Data data) { 379 return changedData.add(data); 380 } 381 382 @Override 383 public void selectedNoteChanged(NoteData noteData) { 384 // Do nothing 385 } 386 387 protected File getPidFile(File osmFile) { 388 return new File(autosaveDir, osmFile.getName().replaceFirst("[.][^.]+$", ".pid")); 389 } 390 391 /** 392 * Replies the list of .osm files still present in autosave dir, that are not currently managed by another instance of JOSM. 393 * These files are hence unsaved layers from an old instance of JOSM that crashed and may be recovered by this instance. 394 * @return The list of .osm files still present in autosave dir, that are not currently managed by another instance of JOSM 395 */ 396 public List<File> getUnsavedLayersFiles() { 397 List<File> result = new ArrayList<>(); 398 try { 399 File[] files = autosaveDir.listFiles( 400 pathname -> OsmImporter.FILE_FILTER.accept(pathname) || NoteImporter.FILE_FILTER.accept(pathname)); 401 if (files == null) 402 return result; 403 for (File file: files) { 404 if (file.isFile()) { 405 boolean skipFile = false; 406 File pidFile = getPidFile(file); 407 if (pidFile.exists()) { 408 try (BufferedReader reader = Files.newBufferedReader(pidFile.toPath(), StandardCharsets.UTF_8)) { 409 String jvmId = reader.readLine(); 410 if (jvmId != null) { 411 String pid = jvmId.split("@", -1)[0]; 412 skipFile = jvmPerfDataFileExists(pid); 413 } 414 } catch (IOException | SecurityException t) { 415 Logging.error(t); 416 } 417 } 418 if (!skipFile) { 419 result.add(file); 420 } 421 } 422 } 423 } catch (SecurityException e) { 424 Logging.log(Logging.LEVEL_ERROR, "Unable to list unsaved layers files", e); 425 } 426 return result; 427 } 428 429 private static boolean jvmPerfDataFileExists(final String jvmId) { 430 File jvmDir = new File(getSystemProperty("java.io.tmpdir") + File.separator + "hsperfdata_" + getSystemProperty("user.name")); 431 if (jvmDir.exists() && jvmDir.canRead()) { 432 File[] files = jvmDir.listFiles((FileFilter) file -> file.getName().equals(jvmId) && file.isFile()); 433 return files != null && files.length == 1; 434 } 435 return false; 436 } 437 438 /** 439 * Recover the unsaved layers and open them asynchronously. 440 * @return A future that can be used to wait for the completion of this task. 441 */ 442 public Future<?> recoverUnsavedLayers() { 443 List<File> files = getUnsavedLayersFiles(); 444 final OpenFileTask openFileTsk = new OpenFileTask(files, null, tr("Restoring files")); 445 final Future<?> openFilesFuture = MainApplication.worker.submit(openFileTsk); 446 return MainApplication.worker.submit(() -> { 447 try { 448 // Wait for opened tasks to be generated. 449 openFilesFuture.get(); 450 for (File f: openFileTsk.getSuccessfullyOpenedFiles()) { 451 moveToDeletedLayersFolder(f); 452 } 453 } catch (InterruptedException | ExecutionException e) { 454 Logging.error(e); 455 } 456 }); 457 } 458 459 /** 460 * Move file to the deleted layers directory. 461 * If moving does not work, it will try to delete the file directly. 462 * Afterwards, if the number of deleted layers gets larger than PROP_DELETED_LAYERS, 463 * some files in the deleted layers directory will be removed. 464 * 465 * @param f the file, usually from the autosave dir 466 */ 467 private void moveToDeletedLayersFolder(File f) { 468 File backupFile = new File(deletedLayersDir, f.getName()); 469 File pidFile = getPidFile(f); 470 471 if (backupFile.exists()) { 472 deletedLayers.remove(backupFile); 473 Utils.deleteFile(backupFile, marktr("Unable to delete old backup file {0}")); 474 } 475 if (f.renameTo(backupFile)) { 476 deletedLayers.add(backupFile); 477 Utils.deleteFile(pidFile); 478 } else { 479 Logging.warn(String.format("Could not move autosaved file %s to %s folder", f.getName(), deletedLayersDir.getName())); 480 // we cannot move to deleted folder, so just try to delete it directly 481 if (Utils.deleteFile(f, marktr("Unable to delete backup file {0}"))) { 482 Utils.deleteFile(pidFile, marktr("Unable to delete PID file {0}")); 483 } 484 } 485 while (deletedLayers.size() > PROP_DELETED_LAYERS.get()) { 486 File next = deletedLayers.remove(); 487 if (next == null) { 488 break; 489 } 490 Utils.deleteFile(next, marktr("Unable to delete archived backup file {0}")); 491 } 492 } 493 494 /** 495 * Mark all unsaved layers as deleted. They are still preserved in the deleted layers folder. 496 */ 497 public void discardUnsavedLayers() { 498 for (File f: getUnsavedLayersFiles()) { 499 moveToDeletedLayersFolder(f); 500 } 501 } 502}