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}