Skip to content

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

FIX: Replace deprecated Array.clear in backup logs (#41834)

Ethan M76e5cf8b709e
diff --git a/frontend/discourse/admin/components/admin-backups-logs.gjs b/frontend/discourse/admin/components/admin-backups-logs.gjs
index 749bd75b5c1..9f3805f8560 100644
--- a/frontend/discourse/admin/components/admin-backups-logs.gjs
+++ b/frontend/discourse/admin/components/admin-backups-logs.gjs
@@ -1,90 +1,100 @@
-/* eslint-disable ember/no-classic-components, ember/no-observers, ember/require-tagless-components */
-import Component from "@ember/component";
-import { scheduleOnce } from "@ember/runloop";
-import { classNames } from "@ember-decorators/component";
-import { observes, on } from "@ember-decorators/object";
+import Component from "@glimmer/component";
+import { tracked } from "@glimmer/tracking";
+import didInsert from "@ember/render-modifiers/modifiers/did-insert";
+import didUpdate from "@ember/render-modifiers/modifiers/did-update";
+import { cancel, scheduleOnce } from "@ember/runloop";
import discourseDebounce from "discourse/lib/debounce";
+import DConditionalLoadingSpinner from "discourse/ui-kit/d-conditional-loading-spinner";
import { i18n } from "discourse-i18n";
-@classNames("admin-backups-logs")
export default class AdminBackupsLogs extends Component {
- showLoadingSpinner = false;
- hasFormattedLogs = false;
- noLogsMessage = i18n("admin.backups.logs.none");
- formattedLogs = "";
- index = 0;
+ @tracked formattedLogs = "";
- _reset() {
- this.setProperties({ formattedLogs: "", index: 0 });
- }
+ registerElement = (element) => {
+ this.#element = element;
+ this.updateLogs();
+ };
+ updateLogs = () => {
+ if (this.args.logs.length === 0) {
+ cancel(this.#formatTimer);
+ this.#formatTimer = null;
+ this.#resetFormattedLogs();
+ return;
+ }
- _scrollDown() {
- const div = this.element;
- div.scrollTop = div.scrollHeight;
- }
+ this.#formatTimer = discourseDebounce(this, this.#formatLogs, 150);
+ };
+ #element;
+ #formatTimer;
+ #lastProcessedLog;
+ #processedLogCount = 0;
- @on("init")
- @observes("logs.[]")
- _resetFormattedLogs() {
- if (this.logs.length === 0) {
- this._reset(); // reset the cached logs whenever the model is reset
- this.renderLogs();
- }
- }
+ #formatLogs = () => {
+ const logs = this.args.logs;
- _updateFormattedLogsFunc() {
- const logs = this.logs;
if (logs.length === 0) {
+ this.#resetFormattedLogs();
return;
}
- // do the log formatting only once for HELLish performance
- let formattedLogs = this.formattedLogs;
- for (let i = this.index, length = logs.length; i < length; i++) {
- const date = logs[i].get("timestamp"),
- message = logs[i].get("message");
- formattedLogs += "[" + date + "] " + message + "\n";
+ if (
+ this.#processedLogCount > logs.length ||
+ (this.#processedLogCount > 0 &&
+ logs[this.#processedLogCount - 1] !== this.#lastProcessedLog)
+ ) {
+ this.#resetFormattedLogs();
}
- // update the formatted logs & cache index
- this.setProperties({
- formattedLogs,
- index: logs.length,
- });
- // force rerender
- this.renderLogs();
- scheduleOnce("afterRender", this, this._scrollDown);
+ let appendedLogs = "";
+ for (let index = this.#processedLogCount; index < logs.length; index++) {
+ const log = logs[index];
+ appendedLogs += `[${log.get("timestamp")}] ${log.get("message")}\n`;
+ }
+
+ this.formattedLogs += appendedLogs;
+ this.#processedLogCount = logs.length;
+ this.#lastProcessedLog = logs.at(-1);
+ scheduleOnce("afterRender", this, this.#performScroll);
+ };
+
+ #performScroll = () => {
+ if (this.#element) {
+ this.#element.scrollTop = this.#element.scrollHeight;
+ }
+ };
+
+ willDestroy() {
+ cancel(this.#formatTimer);
+ this.#element = null;
+ super.willDestroy(...arguments);
}
- @on("init")
- @observes("logs.[]")
- _updateFormattedLogs() {
- discourseDebounce(this, this._updateFormattedLogsFunc, 150);
+ #resetFormattedLogs() {
+ this.formattedLogs = "";
+ this.#processedLogCount = 0;
+ this.#lastProcessedLog = null;
}
- renderLogs() {
- const formattedLogs = this.formattedLogs;
- if (formattedLogs && formattedLogs.length > 0) {
- this.set("hasFormattedLogs", true);
- } else {
- this.set("hasFormattedLogs", false);
- }
- // add a loading indicator
- if (this.get("status.isOperationRunning")) {
- this.set("showLoadingSpinner", true);
- } else {
- this.set("showLoadingSpinner", false);
- }
+ get lastLog() {
+ return this.args.logs.at(-1);
}
<template>
- {{#if this.hasFormattedLogs}}
- <pre>{{this.formattedLogs}}</pre>
- {{else}}
- <p>{{this.noLogsMessage}}</p>
- {{/if}}
- {{#if this.showLoadingSpinner}}
- <div class="spinner small"></div>
- {{/if}}
+ <div
+ ...attributes
+ class="admin-backups-logs"
+ {{didInsert this.registerElement}}
+ {{didUpdate this.updateLogs @logs.length this.lastLog}}
+ >
+ {{#if this.formattedLogs}}
+ <pre>{{this.formattedLogs}}</pre>
+ {{else}}
+ <p>{{i18n "admin.backups.logs.none"}}</p>
+ {{/if}}
+ <DConditionalLoadingSpinner
+ @size="small"
+ @condition={{@status.isOperationRunning}}
+ />
+ </div>
</template>
}
diff --git a/frontend/discourse/tests/integration/components/admin-backups-logs-test.gjs b/frontend/discourse/tests/integration/components/admin-backups-logs-test.gjs
new file mode 100644
index 00000000000..2059bfee90a
--- /dev/null
+++ b/frontend/discourse/tests/integration/components/admin-backups-logs-test.gjs
@@ -0,0 +1,142 @@
+import EmberObject from "@ember/object";
+import { trackedArray } from "@ember/reactive/collections";
+import { render, settled } from "@ember/test-helpers";
+import { module, test } from "qunit";
+import AdminBackupsLogs from "discourse/admin/components/admin-backups-logs";
+import { setupRenderingTest } from "discourse/tests/helpers/component-test";
+import { i18n } from "discourse-i18n";
+
+function createLog(timestamp, message) {
+ return EmberObject.create({ timestamp, message });
+}
+
+module("Integration | Component | AdminBackupsLogs", function (hooks) {
+ setupRenderingTest(hooks);
+
+ test("renders an empty state when there are no logs", async function (assert) {
+ const logs = trackedArray();
+
+ await render(
+ <template>
+ <AdminBackupsLogs @logs={{logs}} class="custom-backup-logs" />
+ </template>
+ );
+
+ assert
+ .dom(".admin-backups-logs")
+ .hasClass("custom-backup-logs", "caller-supplied classes are forwarded");
+ assert
+ .dom(".admin-backups-logs p")
+ .hasText(i18n("admin.backups.logs.none"), "the empty state is shown");
+ assert
+ .dom(".admin-backups-logs pre")
+ .doesNotExist("no log output is rendered");
+ });
+
+ test("renders initial logs in order", async function (assert) {
+ const logs = trackedArray([
+ createLog("10:00:00", "Starting backup"),
+ createLog("10:00:01", "Dumping database"),
+ ]);
+
+ await render(<template><AdminBackupsLogs @logs={{logs}} /></template>);
+
+ assert
+ .dom(".admin-backups-logs pre")
+ .hasText(
+ "[10:00:00] Starting backup\n[10:00:01] Dumping database",
+ "the initial logs are rendered in order"
+ );
+ });
+
+ test("appends multiple logs reactively", async function (assert) {
+ const logs = trackedArray([createLog("10:00:00", "Starting backup")]);
+
+ await render(<template><AdminBackupsLogs @logs={{logs}} /></template>);
+
+ logs.push(
+ createLog("10:00:01", "Dumping database"),
+ createLog("10:00:02", "Backup complete")
+ );
+ await settled();
+
+ assert
+ .dom(".admin-backups-logs pre")
+ .hasText(
+ "[10:00:00] Starting backup\n[10:00:01] Dumping database\n[10:00:02] Backup complete",
+ "the appended logs are rendered after the initial log"
+ );
+ });
+
+ test("starts fresh after logs are cleared", async function (assert) {
+ const logs = trackedArray([
+ createLog("10:00:00", "Old log"),
+ createLog("10:00:01", "Another old log"),
+ ]);
+
+ await render(<template><AdminBackupsLogs @logs={{logs}} /></template>);
+
+ logs.length = 0;
+ await settled();
+
+ assert
+ .dom(".admin-backups-logs p")
+ .hasText(i18n("admin.backups.logs.none"), "the empty state is restored");
+ assert
+ .dom(".admin-backups-logs pre")
+ .doesNotExist("the old log output is removed");
+
+ logs.push(createLog("11:00:00", "New backup"));
+ await settled();
+
+ assert
+ .dom(".admin-backups-logs pre")
+ .hasText(
+ "[11:00:00] New backup",
+ "only logs added after the reset are rendered"
+ );
+ });
+
+ test("starts fresh when logs are cleared and repopulated together", async function (assert) {
+ const logs = trackedArray([createLog("10:00:00", "Old log")]);
+
+ await render(<template><AdminBackupsLogs @logs={{logs}} /></template>);
+
+ logs.length = 0;
+ logs.push(createLog("11:00:00", "New backup"));
+ await settled();
+
+ assert
+ .dom(".admin-backups-logs pre")
+ .hasText("[11:00:00] New backup", "only the replacement log is rendered");
+ });
+
+ test("updates the operation spinner reactively", async function (assert) {
+ const logs = trackedArray();
+ const status = EmberObject.create({ isOperationRunning: false });
+
+ await render(
+ <template>
+ <AdminBackupsLogs @logs={{logs}} @status={{status}} />
+ </template>
+ );
+
+ assert
+ .dom(".admin-backups-logs .spinner")
+ .doesNotExist("the spinner is hidden while no operation is running");
+
+ status.set("isOperationRunning", true);
+ await settled();
+
+ assert
+ .dom(".admin-backups-logs .spinner")
+ .exists("the spinner is shown while an operation is running");
+
+ status.set("isOperationRunning", false);
+ await settled();
+
+ assert
+ .dom(".admin-backups-logs .spinner")
+ .doesNotExist("the spinner is hidden when the operation finishes");
+ });
+});
diff --git a/frontend/discourse/tests/unit/routes/admin-backups-test.js b/frontend/discourse/tests/unit/routes/admin-backups-test.js
new file mode 100644
index 00000000000..de269213f9c
--- /dev/null
+++ b/frontend/discourse/tests/unit/routes/admin-backups-test.js
@@ -0,0 +1,45 @@
+import EmberObject from "@ember/object";
+import { setupTest } from "ember-qunit";
+import { module, test } from "qunit";
+import { logIn } from "discourse/tests/helpers/qunit-helpers";
+
+module("Unit | Route | admin-backups", function (hooks) {
+ setupTest(hooks);
+
+ test("[STARTED] clears the logs and marks the operation as running", function (assert) {
+ const currentUser = logIn(this.owner);
+ const route = this.owner.lookup("route:admin.backups");
+
+ const backupsController = EmberObject.create({
+ model: EmberObject.create({
+ isOperationRunning: false,
+ }),
+ });
+
+ const logsController = this.owner.lookup("controller:admin.backups.logs");
+ const logs = logsController.logs;
+
+ logs.push(EmberObject.create({ message: "existing log" }));
+
+ route.controllerFor = (name) => {
+ if (name === "admin.backups") {
+ return backupsController;
+ }
+
+ if (name === "admin.backups.logs") {
+ return logsController;
+ }
+ };
+
+ route.onMessage({ message: "[STARTED]" });
+
+ assert.true(currentUser.get("hideReadOnlyAlert"));
+ assert.true(backupsController.get("model.isOperationRunning"));
+ assert.strictEqual(logs.length, 0, "existing log entries are removed");
+ assert.strictEqual(
+ logsController.logs,
+ logs,
+ "the existing tracked array object is preserved"
+ );
+ });
+});