first commit

api/app/services/backup_service.ts

@@ -0,0 +1,171 @@
+import { mkdir, readdir, rm, stat } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+import { DateTime } from 'luxon'
+import logger from '@adonisjs/core/services/logger'
+import vpsConfig from '#config/vps'
+import UserError from '#exceptions/user_error'
+import jobRunner, { type JobMeta } from '#services/job_runner'
+
+/**
+ * db-2026-10-11_0300.sql.gz (all the MariaDB databases)
+ * srv-2026-10-11_0300.tar.gz (the /srv folder)
+ */
+const BACKUP_FILE = /^(db|srv)-\d{4}-\d{2}-\d{2}_\d{4}\.(sql\.gz|tar\.gz)$/
+
+export interface BackupFile {
+  name: string
+  type: 'db' | 'srv'
+  size: number
+  createdAt: number
+}
+
+class BackupService {
+  #timer: NodeJS.Timeout | null = null
+  #lastScheduledDay: string | null = null
+
+  async list(): Promise<BackupFile[]> {
+    let names: string[] = []
+    try {
+      names = await readdir(vpsConfig.backups.dir)
+    } catch {
+      return []
+    }
+
+    const files = await Promise.all(
+      names
+        .filter((name) => BACKUP_FILE.test(name))
+        .map(async (name) => {
+          const info = await stat(join(vpsConfig.backups.dir, name))
+          return {
+            name,
+            type: name.startsWith('db-') ? 'db' : 'srv',
+            size: info.size,
+            createdAt: Math.floor(info.mtimeMs / 1000),
+          } satisfies BackupFile
+        })
+    )
+    return files.sort((a, b) => b.createdAt - a.createdAt)
+  }
+
+  /**
+   * Absolute path of a backup, after checking its name (no path traversal).
+   */
+  path(name: string) {
+    if (!BACKUP_FILE.test(name)) throw new UserError('Sauvegarde introuvable.', 404)
+    return join(vpsConfig.backups.dir, name)
+  }
+
+  async delete(name: string) {
+    await rm(this.path(name))
+  }
+
+  run(meta: Omit<JobMeta, 'action' | 'target' | 'lockKey'>) {
+    return jobRunner.start(
+      { ...meta, action: 'Sauvegarde', target: vpsConfig.backups.dir, lockKey: 'backup' },
+      async (ctx) => {
+        const dir = vpsConfig.backups.dir
+        const stamp = DateTime.now().toFormat('yyyy-LL-dd_HHmm')
+        await mkdir(dir, { recursive: true })
+
+        const dbFile = join(dir, `db-${stamp}.sql.gz`)
+        ctx.log('1/2 Export de toutes les bases MariaDB')
+        try {
+          await ctx.run(
+            'docker',
+            [
+              'exec',
+              vpsConfig.mariadb.container,
+              'sh',
+              '-c',
+              'exec "$(command -v mariadb-dump || command -v mysqldump)" -u root -p"${MARIADB_ROOT_PASSWORD:-$MYSQL_ROOT_PASSWORD}" --all-databases --single-transaction --routines --events',
+            ],
+            {
+              display: `docker exec ${vpsConfig.mariadb.container} mariadb-dump --all-databases > ${basename(dbFile)}`,
+              stdoutFile: dbFile,
+              gzipStdout: true,
+            }
+          )
+        } catch (error) {
+          await rm(dbFile, { force: true })
+          throw error
+        }
+
+        /**
+         * node_modules can be reinstalled and db_data holds the raw MariaDB
+         * files, already covered (consistently) by the export above.
+         */
+        const srvFile = join(dir, `srv-${stamp}.tar.gz`)
+        ctx.log(`2/2 Archive de ${vpsConfig.srvRoot}`)
+        try {
+          await ctx.run(
+            'tar',
+            [
+              'czf',
+              srvFile,
+              '--exclude=node_modules',
+              '--exclude=db_data',
+              '-C',
+              dirname(vpsConfig.srvRoot),
+              basename(vpsConfig.srvRoot),
+            ],
+            /**
+             * 1 = some files changed while being read (logs…): not an error.
+             */
+            { okCodes: [0, 1] }
+          )
+        } catch (error) {
+          await rm(srvFile, { force: true })
+          throw error
+        }
+
+        const removed = await this.#applyRetention()
+        if (removed.length) ctx.log(`Anciennes sauvegardes supprimées : ${removed.join(', ')}`)
+      }
+    )
+  }
+
+  /**
+   * Keeps the last N backups of each type.
+   */
+  async #applyRetention() {
+    const files = await this.list()
+    const removed: string[] = []
+    for (const type of ['db', 'srv'] as const) {
+      const old = files.filter((file) => file.type === type).slice(vpsConfig.backups.keep)
+      for (const file of old) {
+        await rm(join(vpsConfig.backups.dir, file.name), { force: true })
+        removed.push(file.name)
+      }
+    }
+    return removed
+  }
+
+  get schedule() {
+    return { dailyAt: vpsConfig.backups.dailyAt, keep: vpsConfig.backups.keep }
+  }
+
+  /**
+   * Daily backup at BACKUP_DAILY_AT (server time).
+   */
+  startSchedule() {
+    const dailyAt = vpsConfig.backups.dailyAt
+    if (!dailyAt) return
+
+    this.#timer = setInterval(() => {
+      const now = DateTime.now()
+      const today = now.toISODate()
+      if (now.toFormat('HH:mm') !== dailyAt || this.#lastScheduledDay === today) return
+      this.#lastScheduledDay = today
+      this.run({ username: 'automatique', ip: null }).catch((error) =>
+        logger.error({ err: error }, 'scheduled backup failed to start')
+      )
+    }, 30_000)
+  }
+
+  stopSchedule() {
+    if (this.#timer) clearInterval(this.#timer)
+  }
+}
+
+const backupService = new BackupService()
+export default backupService