Skip to content

A platform for community discussion. Free, open, simple.

FIX: Keep a backup upload alive when its uploader is re-rendered (#45154)

Jarek Radoszfd50f365ee14
diff --git a/config/locales/client.en.yml b/config/locales/client.en.yml
index 031ce0462e3..f0e47755339 100644
--- a/config/locales/client.en.yml
+++ b/config/locales/client.en.yml
@@ -8982,7 +8982,6 @@ en:
uploading: "Uploading…"
uploading_progress: "Uploading… %{progress}%"
success: "'%{filename}' has successfully been uploaded. The file is now being processed and will take up to a minute to show up in the list."
- error: "There has been an error while uploading '%{filename}': %{message}"
settings: "Settings"
operations:
is_running: "An operation is currently running…"
diff --git a/frontend/discourse/admin/components/uppy-backup-uploader.gjs b/frontend/discourse/admin/components/uppy-backup-uploader.gjs
index a4aa9578ae5..9438bad2486 100644
--- a/frontend/discourse/admin/components/uppy-backup-uploader.gjs
+++ b/frontend/discourse/admin/components/uppy-backup-uploader.gjs
@@ -1,40 +1,13 @@
import Component from "@glimmer/component";
import didInsert from "@ember/render-modifiers/modifiers/did-insert";
-import { service } from "@ember/service";
-import UppyUpload from "discourse/lib/uppy/uppy-upload";
+import willDestroy from "@ember/render-modifiers/modifiers/will-destroy";
import { i18n } from "discourse-i18n";
export default class UppyBackupUploader extends Component {
- @service siteSettings;
-
- uppyUpload = new UppyUpload(this, {
- id: "uppy-backup-uploader",
- type: "backup",
- uploadRootPath: "/admin/backups",
- uploadUrl: "/admin/backups/upload",
-
- // local backups
- useChunkedUploads: this.args.localBackupStorage,
-
- // direct s3 backups
- useMultipartUploadsIfAvailable:
- !this.args.localBackupStorage &&
- this.siteSettings.enable_direct_s3_uploads,
-
- validateUploadedFilesOptions: { skipValidation: true },
-
- // Leaving the tab must not abort a backup upload
- finishUploadsOnDestroy: true,
-
- uploadDone: (responseData) => {
- this.args.done(responseData.file_name);
- },
- });
-
get uploadButtonText() {
- return this.uppyUpload.uploading
+ return this.args.uppyUpload.uploading
? i18n("admin.backups.upload.uploading_progress", {
- progress: this.uppyUpload.uploadProgress,
+ progress: this.args.uppyUpload.uploadProgress,
})
: i18n("admin.backups.upload.label");
}
@@ -43,17 +16,19 @@ export default class UppyBackupUploader extends Component {
<span>
<label
class="btn btn-small btn-primary admin-backups-upload"
- disabled={{this.uppyUpload.uploading}}
+ disabled={{@uppyUpload.uploading}}
title={{i18n "admin.backups.upload.title"}}
...attributes
>
{{this.uploadButtonText}}
+ {{! Render modifiers don't autotrack, so upload state changes don't rebind the input }}
<input
accept=".gz"
class="hidden-upload-field"
- disabled={{this.uppyUpload.uploading}}
+ disabled={{@uppyUpload.uploading}}
type="file"
- {{didInsert this.uppyUpload.setup}}
+ {{didInsert @uppyUpload.attachFileInput}}
+ {{willDestroy @uppyUpload.detachFileInput}}
/>
</label>
</span>
diff --git a/frontend/discourse/admin/controllers/admin/backups/index.js b/frontend/discourse/admin/controllers/admin/backups/index.js
index b585cba5739..e731335f4fe 100644
--- a/frontend/discourse/admin/controllers/admin/backups/index.js
+++ b/frontend/discourse/admin/controllers/admin/backups/index.js
@@ -1,16 +1,23 @@
import Controller, { inject as controller } from "@ember/controller";
import { action, computed, set } from "@ember/object";
import { dependentKeyCompat } from "@ember/object/compat";
+import { trackedArray } from "@ember/reactive/collections";
import { service } from "@ember/service";
+import Backup from "discourse/admin/models/backup";
import { ajax } from "discourse/lib/ajax";
-import { popupAjaxError } from "discourse/lib/ajax-error";
+import { extractError, popupAjaxError } from "discourse/lib/ajax-error";
import getURL from "discourse/lib/get-url";
+import UppyUpload from "discourse/lib/uppy/uppy-upload";
import { i18n } from "discourse-i18n";
export default class AdminBackupsIndexController extends Controller {
@service dialog;
@controller("admin.backups") adminBackups;
+ // Owned here so an upload outlives the uploader, which leaving the tab or closing the mobile
+ // actions menu destroys
+ uppyUpload = this.#createUppyUpload();
+
@computed("adminBackups.model")
get status() {
return this.adminBackups?.model;
@@ -68,4 +75,47 @@ export default class AdminBackupsIndexController extends Controller {
popupAjaxError(err);
}
}
+
+ #createUppyUpload() {
+ const backups = this;
+
+ return new UppyUpload(backups, {
+ id: "uppy-backup-uploader",
+ type: "backup",
+ uploadRootPath: "/admin/backups",
+ uploadUrl: "/admin/backups/upload",
+ validateUploadedFilesOptions: { skipValidation: true },
+
+ // local backups
+ get useChunkedUploads() {
+ return backups.localBackupStorage;
+ },
+
+ // direct s3 backups
+ useMultipartUploadsIfAvailable: true,
+
+ uploadDone: ({ file_name }) => {
+ if (backups.localBackupStorage) {
+ backups.dialog.alert(
+ i18n("admin.backups.upload.success", { filename: file_name })
+ );
+ } else {
+ backups.#refreshBackups();
+ }
+ },
+ });
+ }
+
+ async #refreshBackups() {
+ try {
+ const backups = await Backup.find();
+ this.model = trackedArray(backups.map((backup) => Backup.create(backup)));
+ } catch (error) {
+ this.dialog.alert(
+ i18n("admin.backups.backup_storage_error", {
+ error_message: extractError(error),
+ })
+ );
+ }
+ }
}
diff --git a/frontend/discourse/admin/routes/admin/backups.js b/frontend/discourse/admin/routes/admin/backups.js
index d47b5162253..c8b6b5898f9 100644
--- a/frontend/discourse/admin/routes/admin/backups.js
+++ b/frontend/discourse/admin/routes/admin/backups.js
@@ -4,7 +4,6 @@ import StartBackupModal from "discourse/admin/components/modal/start-backup";
import Backup from "discourse/admin/models/backup";
import BackupStatus from "discourse/admin/models/backup-status";
import { ajax } from "discourse/lib/ajax";
-import { extractError } from "discourse/lib/ajax-error";
import { removeValueFromArray } from "discourse/lib/array-tools";
import { bind } from "discourse/lib/decorators";
import getURL from "discourse/lib/get-url";
@@ -149,36 +148,4 @@ export default class AdminBackupsRoute extends DiscourseRoute {
},
});
}
-
- @action
- uploadSuccess(filename) {
- this.dialog.alert(i18n("admin.backups.upload.success", { filename }));
- }
-
- @action
- uploadError(filename, message) {
- this.dialog.alert(
- i18n("admin.backups.upload.error", { filename, message })
- );
- }
-
- @action
- remoteUploadSuccess() {
- Backup.find()
- .then((backups) => backups.map((backup) => Backup.create(backup)))
- .then((backups) => {
- this.controllerFor("admin.backups.index").set(
- "model",
- backups.map((backup) => Backup.create(backup))
- );
- })
- .catch((error) => {
- this.dialog.alert(
- i18n("admin.backups.backup_storage_error", {
- error_message: extractError(error),
- })
- );
- return [];
- });
- }
}
diff --git a/frontend/discourse/admin/templates/admin/backups/index.gjs b/frontend/discourse/admin/templates/admin/backups/index.gjs
index 35e92c8f299..752d38d3135 100644
--- a/frontend/discourse/admin/templates/admin/backups/index.gjs
+++ b/frontend/discourse/admin/templates/admin/backups/index.gjs
@@ -15,18 +15,10 @@ export default <template>
<:actions as |actions|>
<actions.Wrapped as |wrapped|>
{{#if @controller.siteSettings.enable_backups}}
- {{#if @controller.localBackupStorage}}
- <UppyBackupUploader
- class={{wrapped.buttonClass}}
- @done={{routeAction "uploadSuccess"}}
- @localBackupStorage={{@controller.localBackupStorage}}
- />
- {{else}}
- <UppyBackupUploader
- class={{wrapped.buttonClass}}
- @done={{routeAction "remoteUploadSuccess"}}
- />
- {{/if}}
+ <UppyBackupUploader
+ class={{wrapped.buttonClass}}
+ @uppyUpload={{@controller.uppyUpload}}
+ />
{{/if}}
</actions.Wrapped>
</:actions>
diff --git a/frontend/discourse/app/lib/uppy/uppy-upload.js b/frontend/discourse/app/lib/uppy/uppy-upload.js
index b8df6e15718..29152b84d6f 100644
--- a/frontend/discourse/app/lib/uppy/uppy-upload.js
+++ b/frontend/discourse/app/lib/uppy/uppy-upload.js
@@ -3,13 +3,12 @@ import ApplicationInstance from "@ember/application/instance";
import { warn } from "@ember/debug";
import {
associateDestroyableChild,
- isDestroying,
registerDestructor,
} from "@ember/destroyable";
import EmberObject from "@ember/object";
import { getOwner, setOwner } from "@ember/owner";
import { trackedArray } from "@ember/reactive/collections";
-import { next, run } from "@ember/runloop";
+import { run } from "@ember/runloop";
import { service } from "@ember/service";
import AwsS3 from "@uppy/aws-s3";
import Uppy from "@uppy/core";
@@ -39,8 +38,6 @@ const DEFAULT_CONFIG = {
uploadDone: null,
uploadError: null,
autoStartUploads: true,
- /** let uploads in progress finish after the parent is destroyed */
- finishUploadsOnDestroy: false,
uploadUrl: null,
uploadRootPath: "/uploads",
validateUploadedFilesOptions: {},
@@ -136,17 +133,7 @@ export default class UppyUpload {
}
associateDestroyableChild(parent, this);
- registerDestructor(this, () => {
- // With uploads in progress, #reset() tears down once they finish
- if (
- this.config.finishUploadsOnDestroy &&
- (this.uploading || this.processing)
- ) {
- return;
- }
-
- this.teardown();
- });
+ registerDestructor(this, () => this.teardown());
this.uppyWrapper = new UppyWrapper(getOwner(this));
this.config = lazyMergeConfig(config);
@@ -170,10 +157,7 @@ export default class UppyUpload {
}
teardown() {
- this._fileInputEl?.removeEventListener(
- "change",
- this.#fileInputEventListener
- );
+ this.#unbindFileInput();
if (this.uppyWrapper.uppyInstance) {
this.appEvents.off(
`upload-mixin:${this.config.id}:add-files`,
@@ -193,9 +177,7 @@ export default class UppyUpload {
this.teardown();
if (fileInputEl) {
- this._fileInputEl = fileInputEl;
- this.allowMultipleFiles = this._fileInputEl.multiple;
- this.#bindFileInputChange();
+ this.#bindFileInput(fileInputEl);
}
this.uppyWrapper.uppyInstance = new Uppy({
@@ -412,6 +394,37 @@ export default class UppyUpload {
});
}
+ /**
+ * Binds a file input that may re-render independently. While uploads are queued or running only
+ * the input is swapped, otherwise Uppy is recreated to pick up config changes.
+ *
+ * @param {HTMLInputElement} fileInputEl
+ */
+ @bind
+ attachFileInput(fileInputEl) {
+ if (
+ !this.uppyWrapper.uppyInstance ||
+ !(this.uploading || this.processing || this.filesAwaitingUpload)
+ ) {
+ this.setup(fileInputEl);
+ } else {
+ this.#bindFileInput(fileInputEl);
+ }
+ }
+
+ /**
+ * Unbinds a file input bound with `attachFileInput`, leaving uploads in progress running.
+ *
+ * @param {HTMLInputElement} fileInputEl
+ */
+ @bind
+ detachFileInput(fileInputEl) {
+ if (this._fileInputEl === fileInputEl) {
+ this.#unbindFileInput();
+ this._fileInputEl = null;
+ }
+ }
+
@bind
openPicker() {
this._fileInputEl.click();
@@ -561,13 +574,23 @@ export default class UppyUpload {
return getUrl(uploadUrl) + ".json?client_id=" + this.messageBus.clientId;
}
- #bindFileInputChange() {
+ #bindFileInput(fileInputEl) {
+ this.#unbindFileInput();
+ this._fileInputEl = fileInputEl;
+ this.allowMultipleFiles = fileInputEl.multiple;
this.#fileInputEventListener = bindFileInputChangeListener(
- this._fileInputEl,
+ fileInputEl,
this.addFiles
);
}
+ #unbindFileInput() {
+ this._fileInputEl?.removeEventListener(
+ "change",
+ this.#fileInputEventListener
+ );
+ }
+
#completeExternalUpload(file) {
return ajax(`${this.config.uploadRootPath}/complete-external-upload`, {
type: "POST",
@@ -604,11 +627,6 @@ export default class UppyUpload {
if (this._fileInputEl) {
this._fileInputEl.value = "";
}
-
- if (this.config.finishUploadsOnDestroy && isDestroying(this)) {
- // Deferred because this can run inside one of Uppy's own event handlers
- next(this, this.teardown);
- }
}
#removeInProgressUpload(fileId) {
diff --git a/frontend/discourse/tests/integration/components/uppy-backup-uploader-test.gjs b/frontend/discourse/tests/integration/components/uppy-backup-uploader-test.gjs
new file mode 100644
index 00000000000..10ff5c3c477
--- /dev/null
+++ b/frontend/discourse/tests/integration/components/uppy-backup-uploader-test.gjs
@@ -0,0 +1,100 @@
+import { getOwner } from "@ember/owner";
+import { trackedArray } from "@ember/reactive/collections";
+import { render, triggerEvent, waitUntil } from "@ember/test-helpers";
+import { module, test } from "qunit";
+import sinon from "sinon";
+import UppyBackupUploader from "discourse/admin/components/uppy-backup-uploader";
+import BackupsIndex from "discourse/admin/templates/admin/backups/index";
+import { setupRenderingTest } from "discourse/tests/helpers/component-test";
+import pretender, { response } from "discourse/tests/helpers/create-pretender";
+import { createFile } from "discourse/tests/helpers/qunit-helpers";
+import { i18n } from "discourse-i18n";
+
+module("Integration | Component | UppyBackupUploader", function (hooks) {
+ setupRenderingTest(hooks);
+
+ test("re-rendering mid-upload shows the upload in progress", async function (assert) {
+ this.siteSettings.backup_location = "local";
+ const alert = sinon.stub(getOwner(this).lookup("service:dialog"), "alert");
+
+ let requested = false;
+ let respond;
+ const responded = new Promise((resolve) => (respond = resolve));
+ pretender.post("/admin/backups/upload.json", async () => {
+ requested = true;
+ await responded;
+ return response({});
+ });
+
+ const { uppyUpload } = getOwner(this).lookup(
+ "controller:admin.backups.index"
+ );
+
+ await render(
+ <template><UppyBackupUploader @uppyUpload={{uppyUpload}} /></template>
+ );
+
+ await triggerEvent(".hidden-upload-field", "change", {
+ files: [createFile("backup.tar.gz", "application/gzip")],
+ });
+ await waitUntil(() => requested, { timeout: 5000 });
+
+ // Replaces the uploader with a new one
+ await render(
+ <template><UppyBackupUploader @uppyUpload={{uppyUpload}} /></template>
+ );
+
+ assert
+ .dom(".admin-backups-upload")
+ .hasAttribute("disabled", "", "disables the new uploader")
+ .includesText("Uploading…", "shows the upload in progress");
+
+ const uppyInstance = uppyUpload.uppyWrapper.uppyInstance;
+ respond();
+ await waitUntil(() => alert.called, { timeout: 5000 });
+
+ assert.true(
+ alert.calledWith(
+ i18n("admin.backups.upload.success", { filename: "backup.tar.gz" })
+ ),
+ "reports the finished upload"
+ );
+ assert
+ .dom(".admin-backups-upload")
+ .hasText(i18n("admin.backups.upload.label"), "resets the uploader");
+ assert.strictEqual(
+ uppyUpload.uppyWrapper.uppyInstance,
+ uppyInstance,
+ "doesn't recreate Uppy when the upload finishes"
+ );
+ });
+
+ test("refreshes the list after a remote upload", async function (assert) {
+ this.siteSettings.backup_location = "s3";
+ pretender.post("/admin/backups/upload.json", () => response({}));
+ pretender.get("/admin/backups.json", () =>
+ response([{ filename: "backup.tar.gz", size: 1024 }])
+ );
+
+ const controller = getOwner(this).lookup("controller:admin.backups.index");
+ controller.model = trackedArray();
+
+ await render(
+ <template><BackupsIndex @controller={{controller}} /></template>
+ );
+ await triggerEvent(".hidden-upload-field", "change", {
+ files: [createFile("backup.tar.gz", "application/gzip")],
+ });
+ await waitUntil(() => document.querySelector(".backup-item-row"), {
+ timeout: 5000,
+ });
+
+ assert
+ .dom(".backup-item-row")
+ .hasAttribute(
+ "data-backup-filename",
+ "backup.tar.gz",
+ "shows the uploaded backup"
+ );
+ });
+});
diff --git a/frontend/discourse/tests/unit/lib/uppy/uppy-upload-test.js b/frontend/discourse/tests/unit/lib/uppy/uppy-upload-test.js
index 03c3c3c86af..1cf529fbc9b 100644
--- a/frontend/discourse/tests/unit/lib/uppy/uppy-upload-test.js
+++ b/frontend/discourse/tests/unit/lib/uppy/uppy-upload-test.js
@@ -1,7 +1,7 @@
import { destroy } from "@ember/destroyable";
import { getOwner, setOwner } from "@ember/owner";
import { run } from "@ember/runloop";
-import { waitUntil } from "@ember/test-helpers";
+import { triggerEvent, waitUntil } from "@ember/test-helpers";
import { setupTest } from "ember-qunit";
import { module, test } from "qunit";
import sinon from "sinon";
@@ -289,39 +289,77 @@ module("Unit | Lib | uppy/uppy-upload", function (hooks) {
assert.strictEqual(getOwner(upload), owner, "uses it as the owner");
});
- test("finishUploadsOnDestroy lets an upload in progress finish", async function (assert) {
- const completed = [];
+ test("attachFileInput rebinds an input without interrupting an upload", async function (assert) {
let requested = false;
- let respond;
- const responded = new Promise((resolve) => (respond = resolve));
-
- pretender.post(UPLOAD_URL, async (request) => {
+ pretender.post(UPLOAD_URL, async () => {
requested = true;
- await responded;
- return uploadResponse(request.requestBody.get("file").name);
+ await new Promise(() => {});
});
const upload = new UppyUpload(this.parent, {
- id: "uppy-upload-finish-test",
+ id: "uppy-upload-attach-test",
type: "composer",
- finishUploadsOnDestroy: true,
- uploadDone: ({ file_name }) => completed.push(file_name),
+ uploadDone: () => {},
});
- upload.setup(this.fileInput);
- const uppyDestroy = sinon.spy(upload.uppyWrapper.uppyInstance, "destroy");
+ upload.attachFileInput(this.fileInput);
+ const uppyInstance = upload.uppyWrapper.uppyInstance;
await upload.addFiles([createFile(SIBLING_FILE)]);
await waitUntil(() => requested, { timeout: 5000 });
- run(() => destroy(this.parent));
+ const addFiles = sinon.stub(uppyInstance, "addFiles");
+
+ upload.detachFileInput(this.fileInput);
+ const newInput = document.createElement("input");
+ newInput.type = "file";
+ upload.attachFileInput(newInput);
+
+ assert.strictEqual(
+ upload.uppyWrapper.uppyInstance,
+ uppyInstance,
+ "keeps the Uppy instance"
+ );
+ assert.true(upload.uploading, "keeps uploading");
+
+ await triggerEvent(this.fileInput, "change", {
+ files: [createFile("old.png")],
+ });
+ assert.false(addFiles.called, "unbinds the old input");
- assert.false(uppyDestroy.called, "keeps the upload going");
+ await triggerEvent(newInput, "change", {
+ files: [createFile("new.png")],
+ });
+ assert.true(addFiles.calledOnce, "binds the new input");
+ });
- respond();
- await waitUntil(() => uppyDestroy.called, { timeout: 5000 });
+ test("attachFileInput recreates Uppy only when idle", async function (assert) {
+ const upload = new UppyUpload(this.parent, {
+ id: "uppy-upload-attach-idle-test",
+ type: "composer",
+ autoStartUploads: false,
+ uploadDone: () => {},
+ });
- assert.deepEqual(completed, [SIBLING_FILE], "finishes the upload");
- assert.true(uppyDestroy.calledOnce, "tears down once idle");
+ upload.attachFileInput(this.fileInput);
+ const previous = upload.uppyWrapper.uppyInstance;
+ upload.attachFileInput(this.fileInput);
+ const uppyInstance = upload.uppyWrapper.uppyInstance;
+
+ assert.notStrictEqual(uppyInstance, previous, "recreates an idle instance");
+
+ await upload.addFiles([createFile(SIBLING_FILE)]);
+ upload.attachFileInput(this.fileInput);
+
+ assert.strictEqual(
+ upload.uppyWrapper.uppyInstance,
+ uppyInstance,
+ "keeps an instance with queued files"
+ );
+ assert.strictEqual(
+ uppyInstance.getFiles().length,
+ 1,
+ "keeps the queued file"
+ );
});
test("teardown is a no-op before setup", function (assert) {