new implementation

@xen-orchestra/backups/_backupType.mjs

@@ -1,4 +1,4 @@
-export const isMetadataFile = filename => filename.endsWith('.json') && !filename.endsWith('.json.noncrypted.json')
+export const isMetadataFile = filename => filename.endsWith('.json')
 export const isVhdFile = filename => filename.endsWith('.vhd')
 export const isXvaFile = filename => filename.endsWith('.xva')
 export const isXvaSumFile = filename => filename.endsWith('.xva.checksum')

@xen-orchestra/backups/_runners/_writers/IncrementalRemoteWriter.mjs

@@ -161,7 +161,6 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
     )
 
     metadataContent = {
-      differentialVhds,
       jobId,
       mode: job.mode,
       scheduleId,
@@ -172,7 +171,7 @@ export class IncrementalRemoteWriter extends MixinRemoteWriter(AbstractIncrement
       vifs: deltaExport.vifs,
       vhds,
       vm,
-      vmSnapshot
+      vmSnapshot,
     }
     const { size } = await Task.run({ name: 'transfer' }, async () => {
       let transferSize = 0

@xen-orchestra/backups/formatVmBackups.mjs

@@ -16,7 +16,6 @@ function formatVmBackup(backup) {
           }),
 
     id: backup.id,
-    immutable: backup.immutable,
     jobId: backup.jobId,
     mode: backup.mode,
     scheduleId: backup.scheduleId,

@xen-orchestra/fs/src/abstract.js

@@ -280,9 +280,9 @@ export default class RemoteHandlerAbstract {
     return this._read(typeof file === 'string' ? normalizePath(file) : file, buffer, position)
   }
 
-  async __readFile(file, { flags = 'r' , ignoreEncryption = false} = {}) {
+  async __readFile(file, { flags = 'r' } = {}) {
     const data = await this._readFile(normalizePath(file), { flags })
-    return ignoreEncryption ? data : this.#encryptor.decryptData(data)
+    return this.#encryptor.decryptData(data)
   }
 
   async #rename(oldPath, newPath, { checksum }, createTree = true) {

@xen-orchestra/immutable-backups/computeCacheFilePath.mjs

@@ -0,0 +1,6 @@
+import { basename } from 'node:path'
+import { sha256 } from './directory.mjs'
+
+export function computeCacheFilePath(path, immutabilityCachePath, isFile) {
+  return path.join(immutabilityCachePath, `${sha256(path)}.${isFile ? 'file' : 'dir'}.${basename(path)}`)
+}

@xen-orchestra/immutable-backups/directory.mjs

@@ -1,8 +1,22 @@
 import execa from 'execa'
-export async function makeImmutable(path){
-    return  execa('chattr', ['+i', '-R', path])
+import { createHash } from 'node:crypto'
+import fs from 'node:fs/promises'
+import { computeCacheFilePath } from './computeCacheFilePath.mjs'
+
+export function sha256(content) {
+  return createHash('sha256').update(content).digest('hex')
+}
+
+export async function makeImmutable(dirPath, immutabilityCachePath) {
+  const cacheFileName = computeCacheFilePath(dirPath, immutabilityCachePath, false)
+  await fs.writeFile(cacheFileName, dirPath)
+  await execa('chattr', ['+i', '-R', dirPath])
+  await execa('chattr', ['+i', cacheFileName])
 }
 
-export async function liftImmutability(path){
-    return  execa('chattr', ['-i','-R', path])
-}
+export async function liftImmutability(dirPath, immutabilityCachePath) {
+  const cacheFileName = computeCacheFilePath(dirPath, immutabilityCachePath, false)
+  await execa('chattr', ['-i', cacheFileName])
+  await execa('chattr', ['-i', '-R', dirPath])
+  await fs.unlink(cacheFileName)
+}

@xen-orchestra/immutable-backups/file.mjs

@@ -1,20 +1,20 @@
 import execa from 'execa'
 import fs from 'node:fs/promises'
+import { computeCacheFilePath } from './computeCacheFilePath.mjs'
 
 // this work only on linux like systems
 // this could wokr on windwos : https://4sysops.com/archives/set-and-remove-the-read-only-file-attribute-with-powershell/
 
-export async function makeImmutable(path){
-    await  execa('chattr', ['+i', path])
+export async function makeImmutable(path, immutabilityCachePath) {
+  const cacheFileName = computeCacheFilePath(path, immutabilityCachePath, true)
+  await fs.writeFile(cacheFileName, path)
+  await execa('chattr', ['+i', path])
+  await execa('chattr', ['+i', cacheFileName])
 }
 
-export async function liftImmutability(path){
-    console.log('lift', path)
-    return  execa('chattr', ['-i', path])
-}
-
-export async function isImmutable(path){
-    const {stdout} = await execa('lsattr', [path])
-    const [flags] = stdout.split(' ')
-    return flags.includes('i')
+export async function liftImmutability(filePath, immutabilityCachePath) {
+  const cacheFileName = computeCacheFilePath(filePath, immutabilityCachePath, false)
+  await execa('chattr', ['-i', cacheFileName])
+  await execa('chattr', ['-i', filePath])
+  await fs.unlink(cacheFileName)
 }

@xen-orchestra/immutable-backups/newFileWatcher.mjs

@@ -0,0 +1,22 @@
+import { asyncEach } from '@vates/async-each'
+import fs from 'node:fs/promises'
+
+export async function watchForExistingAndNew(path, callback) {
+  asyncEach(fs.readdir(path, entry => callback(entry, false, watcher)))
+
+  const watcher = fs.watch(path)
+
+  for await (const { eventType, filename } of watcher) {
+    if (eventType === 'change') {
+      continue
+    }
+    if (filename.startsWith('.')) {
+      // temp file during upload
+      continue
+    }
+    const stat = await fs.stat(path)
+    if (stat.mtimeMs === stat.birthtimeMs) {
+      await callback(filename, true, watcher)
+    }
+  }
+}

@xen-orchestra/immutable-backups/package.json

@@ -18,6 +18,7 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
+    "@vates/async-each": "^1.0.0",
     "@xen-orchestra/backups": "^0.44.2",
     "@xen-orchestra/log": "^0.6.0",
     "execa": "^5.0.0",

@xen-orchestra/immutable-backups/poolOrMetadata.mjs

@@ -0,0 +1,26 @@
+import { join } from 'node:path'
+import * as Directory from './file.mjs'
+import { watchForExistingAndNew } from './newFileWatcher.mjs'
+
+async function waitForCompletion(path) {
+  await watchForExistingAndNew(path, (pathInDirectory, isNew, watcher) => {
+    if (!isNew) {
+      return
+    }
+    if (pathInDirectory === 'metadata.json') {
+      watcher.close()
+      // will end the watcher, stop this loop and return
+    }
+  })
+}
+
+export async function watch(basePath, immutabilityCachePath) {
+  await watchForExistingAndNew(basePath, async (pathInDirectory, isNew) => {
+    if (!isNew) {
+      return
+    }
+    const path = join(basePath, pathInDirectory)
+    await waitForCompletion(path)
+    await Directory.makeImmutable(path, immutabilityCachePath)
+  })
+}