Ticket #9446: 9446.patch

src/org/openstreetmap/josm/actions/UploadAction.java

@@ -11 +11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.function.Consumer;
 
 import javax.swing.JOptionPane;
 
@@ -36 +40 @@
 import org.openstreetmap.josm.io.UploadStrategySpecification;
 import org.openstreetmap.josm.spi.preferences.Config;
 import org.openstreetmap.josm.tools.ImageProvider;
+import org.openstreetmap.josm.tools.JosmRuntimeException;
 import org.openstreetmap.josm.tools.Logging;
 import org.openstreetmap.josm.tools.Shortcut;
 import org.openstreetmap.josm.tools.Utils;
@@ -203 +208 @@
      * @return true, if the preconditions are met; false, otherwise
      */
     public static boolean checkPreUploadConditions(AbstractModifiableLayer layer, APIDataSet apiData) {
+        try {
+            return checkPreUploadConditionsAsync(layer, apiData, null).get();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new JosmRuntimeException(e);
+        } catch (ExecutionException e) {
+            throw new JosmRuntimeException(e);
+        }
+    }
+
+    /**
+     * Check whether the preconditions are met to upload data in <code>apiData</code>.
+     * Makes sure upload is allowed, primitives in <code>apiData</code> don't participate in conflicts and
+     * runs the installed {@link UploadHook}s.
+     *
+     * @param layer the source layer of the data to be uploaded
+     * @param apiData the data to be uploaded
+     * @param onFinish {@code true} if the preconditions are met; {@code false}, otherwise
+     * @return A future that completes when the checks are finished
+     */
+    public static Future<Boolean> checkPreUploadConditionsAsync(AbstractModifiableLayer layer, APIDataSet apiData, Consumer<Boolean> onFinish) {
+        final CompletableFuture<Boolean> future = new CompletableFuture<>();
+        if (onFinish != null) {
+            future.thenAccept(onFinish);
+        }
         if (layer.isUploadDiscouraged() && warnUploadDiscouraged(layer)) {
-            return false;
+            future.complete(false);
         }
         if (layer instanceof OsmDataLayer) {
             OsmDataLayer osmLayer = (OsmDataLayer) layer;
             ConflictCollection conflicts = osmLayer.getConflicts();
             if (apiData.participatesInConflict(conflicts)) {
                 alertUnresolvedConflicts(osmLayer);
-                return false;
+                if (!future.isDone()) {
+                    future.complete(false);
+                }
             }
         }
         // Call all upload hooks in sequence.
-        // FIXME: this should become an asynchronous task
-        //
-        if (apiData != null) {
-            return UPLOAD_HOOKS.stream().allMatch(hook -> hook.checkUpload(apiData));
+        if (!future.isDone()) {
+            MainApplication.worker.execute(() -> {
+                boolean hooks = true;
+                if (apiData != null) {
+                    hooks = UPLOAD_HOOKS.stream().allMatch(hook -> hook.checkUpload(apiData));
+                }
+                future.complete(hooks);
+            });
         }
-
-        return true;
+        return future;
     }
 
     /**
@@ -235 +270 @@
             new Notification(tr("No changes to upload.")).show();
             return;
         }
-        if (!checkPreUploadConditions(layer, apiData))
-            return;
+        checkPreUploadConditionsAsync(layer, apiData, passed -> GuiHelper.runInEDT(() -> {
+            if (Boolean.TRUE.equals(passed)) {
+                realUploadData(layer, apiData);
+            } else {
+                new Notification(tr("One of the upload verification processes failed")).show();
+            }
+        }));
+    }
+
+    /**
+     * Uploads data to the OSM API.
+     *
+     * @param layer the source layer for the data to upload
+     * @param apiData the primitives to be added, updated, or deleted
+     */
+    private static void realUploadData(final OsmDataLayer layer, final APIDataSet apiData) {
 
         ChangesetUpdater.check();
 

src/org/openstreetmap/josm/actions/upload/ValidateUploadHook.java

@@ -5 +5 @@
 
 import java.awt.Dimension;
 import java.awt.GridBagLayout;
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
 
 import org.openstreetmap.josm.data.APIDataSet;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
-import org.openstreetmap.josm.data.preferences.sources.ValidatorPrefHelper;
 import org.openstreetmap.josm.data.validation.OsmValidator;
-import org.openstreetmap.josm.data.validation.Severity;
-import org.openstreetmap.josm.data.validation.Test;
 import org.openstreetmap.josm.data.validation.TestError;
+import org.openstreetmap.josm.data.validation.ValidationTask;
 import org.openstreetmap.josm.data.validation.util.AggregatePrimitivesVisitor;
 import org.openstreetmap.josm.gui.ExtendedDialog;
 import org.openstreetmap.josm.gui.MainApplication;
-import org.openstreetmap.josm.gui.MapFrame;
 import org.openstreetmap.josm.gui.dialogs.validator.ValidatorTreePanel;
-import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.gui.layer.ValidatorLayer;
 import org.openstreetmap.josm.gui.util.GuiHelper;
 import org.openstreetmap.josm.gui.widgets.HtmlPanel;
@@ -48 +44 @@
      */
     @Override
     public boolean checkUpload(APIDataSet apiDataSet) {
-
-        OsmValidator.initializeTests();
-        Collection<Test> tests = OsmValidator.getEnabledTests(true);
-        if (tests.isEmpty())
-            return true;
-
+        AtomicBoolean returnCode = new AtomicBoolean();
         AggregatePrimitivesVisitor v = new AggregatePrimitivesVisitor();
         v.visit(apiDataSet.getPrimitivesToAdd());
-        Collection<OsmPrimitive> selection = v.visit(apiDataSet.getPrimitivesToUpdate());
-
-        List<TestError> errors = new ArrayList<>(30);
-        for (Test test : tests) {
-            test.setBeforeUpload(true);
-            test.setPartialSelection(true);
-            test.startTest(null);
-            test.visit(selection);
-            test.endTest();
-            if (ValidatorPrefHelper.PREF_OTHER.get() && ValidatorPrefHelper.PREF_OTHER_UPLOAD.get()) {
-                errors.addAll(test.getErrors());
+        Collection<OsmPrimitive> visited = v.visit(apiDataSet.getPrimitivesToUpdate());
+        OsmValidator.initializeTests();
+        new ValidationTask(errors -> {
+            if (errors.stream().allMatch(TestError::isIgnored)) {
+                returnCode.set(true);
             } else {
-                for (TestError e : test.getErrors()) {
-                    if (e.getSeverity() != Severity.OTHER) {
-                        errors.add(e);
-                    }
-                }
+                // Unfortunately, the progress monitor is not "finished" until after `finish` is called, so we will
+                // have a ProgressMonitor open behind the error screen. Fortunately, the error screen appears in front
+                // of the progress monitor.
+                GuiHelper.runInEDTAndWait(() -> returnCode.set(displayErrorScreen(errors)));
             }
-            test.clear();
-            test.setBeforeUpload(false);
-        }
-
-        if (Boolean.TRUE.equals(ValidatorPrefHelper.PREF_USE_IGNORE.get())) {
-            errors.forEach(TestError::updateIgnored);
-        }
-
-        OsmDataLayer editLayer = MainApplication.getLayerManager().getEditLayer();
-        if (editLayer != null) {
-            editLayer.validationErrors.clear();
-            editLayer.validationErrors.addAll(errors);
-        }
-        MapFrame map = MainApplication.getMap();
-        if (map != null) {
-            map.validatorDialog.tree.setErrors(errors);
-        }
-        if (errors.stream().allMatch(TestError::isIgnored))
-            return true;
+        }, null, OsmValidator.getEnabledTests(true), visited, null, true).run();
 
-        return displayErrorScreen(errors);
+        return returnCode.get();
     }
 
     /**

src/org/openstreetmap/josm/data/validation/ValidationTask.java

@@ -3 +3 @@
 
 import static org.openstreetmap.josm.tools.I18n.tr;
 
+import java.awt.GraphicsEnvironment;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
 
 import javax.swing.JOptionPane;
 
@@ -25 +28 @@
  * Asynchronous task for running a collection of tests against a collection of primitives
  */
 public class ValidationTask extends PleaseWaitRunnable {
+    private final Consumer<List<TestError>> onFinish;
     private Collection<Test> tests;
     private final Collection<OsmPrimitive> validatedPrimitives;
     private final Collection<OsmPrimitive> formerValidatedPrimitives;
+    private final boolean beforeUpload;
     private boolean canceled;
     private List<TestError> errors;
+    private BiConsumer<ValidationTask, Test> testConsumer;
 
     /**
      * Constructs a new {@code ValidationTask}
@@ -44 +50 @@
         this(new PleaseWaitProgressMonitor(tr("Validating")), tests, validatedPrimitives, formerValidatedPrimitives);
     }
 
-    protected ValidationTask(ProgressMonitor progressMonitor,
-                             Collection<Test> tests,
-                             Collection<OsmPrimitive> validatedPrimitives,
-                             Collection<OsmPrimitive> formerValidatedPrimitives) {
-        super(tr("Validating"), progressMonitor, false /*don't ignore exceptions */);
+    /**
+     * Constructs a new {@code ValidationTask}
+     *
+     * @param onFinish                  called when the tests are finished
+     * @param progressMonitor           the progress monitor to update with test progress
+     * @param tests                     the tests to run
+     * @param validatedPrimitives       the collection of primitives to validate.
+     * @param formerValidatedPrimitives the last collection of primitives being validates. May be null.
+     * @param beforeUpload              {@code true} if this is being run prior to upload
+     * @since xxx
+     */
+    public ValidationTask(Consumer<List<TestError>> onFinish,
+            ProgressMonitor progressMonitor,
+            Collection<Test> tests,
+            Collection<OsmPrimitive> validatedPrimitives,
+            Collection<OsmPrimitive> formerValidatedPrimitives,
+            boolean beforeUpload) {
+        super(tr("Validating"),
+                progressMonitor != null ? progressMonitor : new PleaseWaitProgressMonitor(tr("Validating")),
+                false /*don't ignore exceptions */);
+        this.onFinish = onFinish;
         this.validatedPrimitives = validatedPrimitives;
         this.formerValidatedPrimitives = formerValidatedPrimitives;
         this.tests = tests;
+        this.beforeUpload = beforeUpload;
+    }
+
+    protected ValidationTask(ProgressMonitor progressMonitor,
+            Collection<Test> tests,
+            Collection<OsmPrimitive> validatedPrimitives,
+            Collection<OsmPrimitive> formerValidatedPrimitives) {
+        this(null, progressMonitor, tests, validatedPrimitives, formerValidatedPrimitives, false);
     }
 
     @Override
@@ -63 +93 @@
     protected void finish() {
         if (canceled) return;
 
-        // update GUI on Swing EDT
-        GuiHelper.runInEDT(() -> {
-            MapFrame map = MainApplication.getMap();
-            map.validatorDialog.unfurlDialog();
-            map.validatorDialog.tree.setErrors(errors);
-            //FIXME: nicer way to find / invalidate the corresponding error layer
-            MainApplication.getLayerManager().getLayersOfType(ValidatorLayer.class).forEach(ValidatorLayer::invalidate);
-            if (!errors.isEmpty()) {
-                OsmValidator.initializeErrorLayer();
-            }
-        });
+        if (!GraphicsEnvironment.isHeadless() && MainApplication.getMap() != null) {
+            // update GUI on Swing EDT
+            GuiHelper.runInEDT(() -> {
+                MapFrame map = MainApplication.getMap();
+                map.validatorDialog.unfurlDialog();
+                map.validatorDialog.tree.setErrors(errors);
+                //FIXME: nicer way to find / invalidate the corresponding error layer
+                MainApplication.getLayerManager().getLayersOfType(ValidatorLayer.class).forEach(ValidatorLayer::invalidate);
+                if (!errors.isEmpty()) {
+                    OsmValidator.initializeErrorLayer();
+                }
+            });
+        }
+        if (this.onFinish != null) {
+            this.onFinish.accept(this.errors);
+        }
     }
 
     @Override
@@ -88 +123 @@
                 return;
             testCounter++;
             getProgressMonitor().setCustomText(tr("Test {0}/{1}: Starting {2}", testCounter, tests.size(), test.getName()));
-            test.setBeforeUpload(false);
+            test.setBeforeUpload(this.beforeUpload);
             test.setPartialSelection(formerValidatedPrimitives != null);
             test.startTest(getProgressMonitor().createSubTaskMonitor(validatedPrimitives.size(), false));
             test.visit(validatedPrimitives);
             test.endTest();
             errors.addAll(test.getErrors());
+            if (this.testConsumer != null) {
+                this.testConsumer.accept(this, test);
+            }
             test.clear();
+            test.setBeforeUpload(false);
         }
         tests = null;
         if (Boolean.TRUE.equals(ValidatorPrefHelper.PREF_USE_IGNORE.get())) {
@@ -124 +163 @@
     public List<TestError> getErrors() {
         return errors;
     }
+
+    /**
+     * A test consumer to avoid filling up memory. A test consumer <i>may</i> remove tests it has consumed.
+     * @param testConsumer The consumer which takes a {@link ValidationTask} ({@code this}) and the test that finished.
+     * @since xxx
+     */
+    public void setTestConsumer(BiConsumer<ValidationTask, Test> testConsumer) {
+        this.testConsumer = testConsumer;
+    }
 }

src/org/openstreetmap/josm/data/validation/ValidatorCLI.java

@@ -10 +10 @@
 import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -25 +26 @@
 import java.util.logging.Level;
 import java.util.stream.Collectors;
 
+import javax.json.JsonObject;
+
 import org.apache.commons.compress.utils.FileNameUtils;
 import org.openstreetmap.josm.actions.ExtensionFileFilter;
 import org.openstreetmap.josm.cli.CLIModule;
@@ -174 +177 @@
             fileMonitor.beginTask(tr("Processing files..."), this.input.size());
             for (String inputFile : this.input) {
                 if (inputFile.endsWith(".validator.mapcss")) {
-                    this.processValidatorFile(inputFile);
+                    processValidatorFile(inputFile);
                 } else if (inputFile.endsWith(".mapcss")) {
-                    this.processMapcssFile(inputFile);
+                    processMapcssFile(inputFile);
                 } else {
                     this.processFile(inputFile);
                 }
@@ -195 +198 @@
      * @param inputFile The mapcss file to validate
      * @throws ParseException if the file does not match the mapcss syntax
      */
-    private void processMapcssFile(final String inputFile) throws ParseException {
+    private static void processMapcssFile(final String inputFile) throws ParseException {
         final MapCSSStyleSource styleSource = new MapCSSStyleSource(new File(inputFile).toURI().getPath(), inputFile, inputFile);
         styleSource.loadStyleSource();
         if (!styleSource.getErrors().isEmpty()) {
@@ -212 +215 @@
      * @throws IOException if there is a problem reading the file
      * @throws ParseException if the file does not match the validator mapcss syntax
      */
-    private void processValidatorFile(final String inputFile) throws ParseException, IOException {
+    private static void processValidatorFile(final String inputFile) throws ParseException, IOException {
         // Check asserts
         Config.getPref().putBoolean("validator.check_assert_local_rules", true);
         final MapCSSTagChecker mapCSSTagChecker = new MapCSSTagChecker();
@@ -254 +257 @@
         OsmDataLayer dataLayer = null;
         try {
             Logging.info(task);
-            OsmValidator.initializeTests();
             dataLayer = MainApplication.getLayerManager().getLayersOfType(OsmDataLayer.class)
                     .stream().filter(layer -> inputFileFile.equals(layer.getAssociatedFile()))
                     .findFirst().orElseThrow(() -> new JosmRuntimeException(tr("Could not find a layer for {0}", inputFile)));
@@ -267 +269 @@
                     }
                 }
             }
-            Collection<Test> tests = OsmValidator.getEnabledTests(false);
-            if (Files.isRegularFile(Paths.get(outputFile)) && !Files.deleteIfExists(Paths.get(outputFile))) {
+            Path path = Paths.get(outputFile);
+            if (path.toFile().isFile() && !Files.deleteIfExists(path)) {
                 Logging.error("Could not delete {0}, attempting to append", outputFile);
             }
             GeoJSONMapRouletteWriter geoJSONMapRouletteWriter = new GeoJSONMapRouletteWriter(dataSet);
-            try (OutputStream fileOutputStream = Files.newOutputStream(Paths.get(outputFile))) {
-                tests.parallelStream().forEach(test -> runTest(test, geoJSONMapRouletteWriter, fileOutputStream, dataSet));
+            OsmValidator.initializeTests();
+
+            try (OutputStream fileOutputStream = Files.newOutputStream(path)) {
+                // The first writeErrors catches anything that was written, for whatever reason. This is probably never
+                // going to be called.
+                ValidationTask validationTask = new ValidationTask(errors -> writeErrors(geoJSONMapRouletteWriter, fileOutputStream, errors),
+                        progressMonitorFactory.get(), OsmValidator.getEnabledTests(false),
+                        dataSet.allPrimitives(), Collections.emptyList(), false);
+                // This avoids keeping errors in memory
+                validationTask.setTestConsumer((t, test) -> {
+                    writeErrors(geoJSONMapRouletteWriter, fileOutputStream, test.getErrors());
+                    t.getErrors().removeIf(test.getErrors()::contains);
+                });
+                validationTask.run();
             }
         } finally {
             if (dataLayer != null) {
@@ -283 +297 @@
         }
     }
 
+    private void writeErrors(GeoJSONMapRouletteWriter geoJSONMapRouletteWriter, OutputStream fileOutputStream,
+            Collection<TestError> errors) {
+        for (TestError error : errors) {
+            Optional<JsonObject> object = geoJSONMapRouletteWriter.write(error);
+            if (object.isPresent()) {
+                try {
+                    writeToFile(fileOutputStream, object.get().toString().getBytes(StandardCharsets.UTF_8));
+                } catch (IOException e) {
+                    throw new JosmRuntimeException(e);
+                }
+            }
+        }
+    }
+
     /**
      * Get the default output name
      * @param inputString The input file
@@ -299 +327 @@
         return FileNameUtils.getBaseName(FileNameUtils.getBaseName(inputString)) + ".geojson";
     }
 
-    /**
-     * Run a test
-     * @param test The test to run
-     * @param geoJSONMapRouletteWriter The object to use to create challenges
-     * @param fileOutputStream The location to write data to
-     * @param dataSet The dataset to check
-     */
-    private void runTest(final Test test, final GeoJSONMapRouletteWriter geoJSONMapRouletteWriter,
-            final OutputStream fileOutputStream, DataSet dataSet) {
-        test.startTest(progressMonitorFactory.get());
-        test.visit(dataSet.allPrimitives());
-        test.endTest();
-        test.getErrors().stream().map(geoJSONMapRouletteWriter::write)
-                .filter(Optional::isPresent).map(Optional::get)
-                .map(jsonObject -> jsonObject.toString().getBytes(StandardCharsets.UTF_8)).forEach(bytes -> {
-                    try {
-                        writeToFile(fileOutputStream, bytes);
-                    } catch (IOException e) {
-                        throw new JosmRuntimeException(e);
-                    }
-                });
-        test.clear();
-    }
-
     /**
      * Write to a file. Synchronized to avoid writing to the same file in different threads.
      *

src/org/openstreetmap/josm/gui/io/SaveLayersDialog.java

@@ -553 +553 @@
             for (final SaveLayerInfo layerInfo: toUpload) {
                 AbstractModifiableLayer layer = layerInfo.getLayer();
                 if (canceled) {
-                    model.setUploadState(layer, UploadOrSaveState.CANCELED);
+                    GuiHelper.runInEDTAndWait(() -> model.setUploadState(layer, UploadOrSaveState.CANCELED));
                     continue;
                 }
-                monitor.subTask(tr("Preparing layer ''{0}'' for upload ...", layerInfo.getName()));
+                GuiHelper.runInEDTAndWait(() -> monitor.subTask(tr("Preparing layer ''{0}'' for upload ...", layerInfo.getName())));
 
+                // checkPreUploadConditions must not be run in the EDT to avoid deadlocks
                 if (!UploadAction.checkPreUploadConditions(layer)) {
-                    model.setUploadState(layer, UploadOrSaveState.FAILED);
+                    GuiHelper.runInEDTAndWait(() -> model.setUploadState(layer, UploadOrSaveState.FAILED));
                     continue;
                 }
 
-                AbstractUploadDialog dialog = layer.getUploadDialog();
-                if (dialog != null) {
-                    dialog.setVisible(true);
-                    if (dialog.isCanceled()) {
-                        model.setUploadState(layer, UploadOrSaveState.CANCELED);
-                        continue;
-                    }
-                    dialog.rememberUserInput();
-                }
+                GuiHelper.runInEDTAndWait(() -> uploadLayersUploadModelStateOnFinish(layer));
+                currentTask = null;
+            }
+        }
 
-                currentTask = layer.createUploadTask(monitor);
-                if (currentTask == null) {
-                    model.setUploadState(layer, UploadOrSaveState.FAILED);
-                    continue;
-                }
-                Future<?> currentFuture = worker.submit(currentTask);
-                try {
-                    // wait for the asynchronous task to complete
-                    currentFuture.get();
-                } catch (CancellationException e) {
-                    Logging.trace(e);
-                    model.setUploadState(layer, UploadOrSaveState.CANCELED);
-                } catch (InterruptedException | ExecutionException e) {
-                    Logging.error(e);
-                    model.setUploadState(layer, UploadOrSaveState.FAILED);
-                    ExceptionDialogUtil.explainException(e);
-                }
-                if (currentTask.isCanceled()) {
+        /**
+         * Update the {@link #model} state on upload finish
+         * @param layer The layer that has been saved
+         */
+        private void uploadLayersUploadModelStateOnFinish(AbstractModifiableLayer layer) {
+            AbstractUploadDialog dialog = layer.getUploadDialog();
+            if (dialog != null) {
+                dialog.setVisible(true);
+                if (dialog.isCanceled()) {
                     model.setUploadState(layer, UploadOrSaveState.CANCELED);
-                } else if (currentTask.isFailed()) {
-                    Logging.error(currentTask.getLastException());
-                    ExceptionDialogUtil.explainException(currentTask.getLastException());
-                    model.setUploadState(layer, UploadOrSaveState.FAILED);
-                } else {
-                    model.setUploadState(layer, UploadOrSaveState.OK);
+                    return;
                 }
-                currentTask = null;
+                dialog.rememberUserInput();
+            }
+
+            currentTask = layer.createUploadTask(monitor);
+            if (currentTask == null) {
+                model.setUploadState(layer, UploadOrSaveState.FAILED);
+                return;
+            }
+            Future<?> currentFuture = worker.submit(currentTask);
+            try {
+                // wait for the asynchronous task to complete
+                currentFuture.get();
+            } catch (CancellationException e) {
+                Logging.trace(e);
+                model.setUploadState(layer, UploadOrSaveState.CANCELED);
+            } catch (InterruptedException | ExecutionException e) {
+                Logging.error(e);
+                model.setUploadState(layer, UploadOrSaveState.FAILED);
+                ExceptionDialogUtil.explainException(e);
+            }
+            if (currentTask.isCanceled()) {
+                model.setUploadState(layer, UploadOrSaveState.CANCELED);
+            } else if (currentTask.isFailed()) {
+                Logging.error(currentTask.getLastException());
+                ExceptionDialogUtil.explainException(currentTask.getLastException());
+                model.setUploadState(layer, UploadOrSaveState.FAILED);
+            } else {
+                model.setUploadState(layer, UploadOrSaveState.OK);
             }
         }
 
@@ -669 +678 @@
 
         @Override
         public void run() {
+            GuiHelper.runInEDTAndWait(() -> model.setMode(SaveLayersModel.Mode.UPLOADING_AND_SAVING));
+            // We very specifically do not want to block the EDT or the worker thread when validating
+            List<SaveLayerInfo> toUpload = model.getLayersToUpload();
+            if (!toUpload.isEmpty()) {
+                uploadLayers(toUpload);
+            }
             GuiHelper.runInEDTAndWait(() -> {
-                model.setMode(SaveLayersModel.Mode.UPLOADING_AND_SAVING);
-                List<SaveLayerInfo> toUpload = model.getLayersToUpload();
-                if (!toUpload.isEmpty()) {
-                    uploadLayers(toUpload);
-                }
                 List<SaveLayerInfo> toSave = model.getLayersToSave();
                 if (!toSave.isEmpty()) {
                     saveLayers(toSave);