feat: file backups (#870)

Author: moughxyz

app/javascripts/Main/Backups/BackupsManager.ts

@@ -5,7 +5,14 @@ import { AppMessageType, MessageType } from '../../../../test/TestIpcMessage'
 import { AppState } from '../../../application'
 import { MessageToWebApp } from '../../Shared/IpcMessages'
 import { BackupsManagerInterface } from './BackupsManagerInterface'
-import { deleteDir, deleteDirContents, ensureDirectoryExists, FileDoesNotExist, moveFiles } from '../Utils/FileUtils'
+import {
+  deleteDir,
+  deleteDirContents,
+  ensureDirectoryExists,
+  FileDoesNotExist,
+  moveFiles,
+  openDirectoryPicker,
+} from '../Utils/FileUtils'
 import { Paths } from '../Types/Paths'
 import { StoreKeys } from '../Store'
 import { backups as str } from '../Strings'
@@ -194,12 +201,14 @@ export function createBackupsManager(webContents: WebContents, appState: AppStat
       await deleteDirContents(backupsLocation)
       return copyDecryptScript(backupsLocation)
     },
+
     async changeBackupsLocation() {
-      const result = await dialog.showOpenDialog({
-        properties: ['openDirectory', 'showHiddenFiles', 'createDirectory'],
-      })
-      if (result.filePaths.length === 0) return
-      const path = result.filePaths[0]
+      const path = await openDirectoryPicker()
+
+      if (!path) {
+        return
+      }
+
       try {
         await setBackupsLocation(path)
         performBackup()

app/javascripts/Main/FileBackups/FileBackupsManager.ts

@@ -0,0 +1,156 @@
+import { FileBackupsDevice, FileBackupsMapping } from '@web/Device/DesktopSnjsExports'
+import { AppState } from 'app/application'
+import { StoreKeys } from '../Store'
+import {
+  ensureDirectoryExists,
+  moveDirContents,
+  openDirectoryPicker,
+  readJSONFile,
+  writeFile,
+  writeJSONFile,
+} from '../Utils/FileUtils'
+import { FileDownloader } from './FileDownloader'
+import { shell } from 'electron'
+
+export const FileBackupsConstantsV1 = {
+  Version: '1.0.0',
+  MetadataFileName: 'metadata.sn.json',
+  BinaryFileName: 'file.encrypted',
+}
+
+export class FilesBackupManager implements FileBackupsDevice {
+  constructor(private appState: AppState) {}
+
+  public isFilesBackupsEnabled(): Promise<boolean> {
+    return Promise.resolve(this.appState.store.get(StoreKeys.FileBackupsEnabled))
+  }
+
+  public async enableFilesBackups(): Promise<void> {
+    const currentLocation = await this.getFilesBackupsLocation()
+
+    if (!currentLocation) {
+      const result = await this.changeFilesBackupsLocation()
+
+      if (!result) {
+        return
+      }
+    }
+
+    this.appState.store.set(StoreKeys.FileBackupsEnabled, true)
+
+    const mapping = this.getMappingFileFromDisk()
+
+    if (!mapping) {
+      await this.saveFilesBackupsMappingFile(this.defaultMappingFileValue())
+    }
+  }
+
+  public disableFilesBackups(): Promise<void> {
+    this.appState.store.set(StoreKeys.FileBackupsEnabled, false)
+
+    return Promise.resolve()
+  }
+
+  public async changeFilesBackupsLocation(): Promise<string | undefined> {
+    const newPath = await openDirectoryPicker()
+
+    if (!newPath) {
+      return undefined
+    }
+
+    const oldPath = await this.getFilesBackupsLocation()
+
+    if (oldPath) {
+      await moveDirContents(oldPath, newPath)
+    }
+
+    this.appState.store.set(StoreKeys.FileBackupsLocation, newPath)
+
+    return newPath
+  }
+
+  public getFilesBackupsLocation(): Promise<string> {
+    return Promise.resolve(this.appState.store.get(StoreKeys.FileBackupsLocation))
+  }
+
+  private getMappingFileLocation(): string {
+    const base = this.appState.store.get(StoreKeys.FileBackupsLocation)
+    return `${base}/info.json`
+  }
+
+  private async getMappingFileFromDisk(): Promise<FileBackupsMapping | undefined> {
+    return readJSONFile<FileBackupsMapping>(this.getMappingFileLocation())
+  }
+
+  private defaultMappingFileValue(): FileBackupsMapping {
+    return { version: FileBackupsConstantsV1.Version, files: {} }
+  }
+
+  async getFilesBackupsMappingFile(): Promise<FileBackupsMapping> {
+    const data = await this.getMappingFileFromDisk()
+
+    if (!data) {
+      return this.defaultMappingFileValue()
+    }
+
+    return data
+  }
+
+  async openFilesBackupsLocation(): Promise<void> {
+    const location = await this.getFilesBackupsLocation()
+
+    shell.openPath(location)
+  }
+
+  async saveFilesBackupsMappingFile(file: FileBackupsMapping): Promise<'success' | 'failed'> {
+    await writeJSONFile(this.getMappingFileLocation(), file)
+
+    return 'success'
+  }
+
+  async saveFilesBackupsFile(
+    uuid: string,
+    metaFile: string,
+    downloadRequest: {
+      chunkSizes: number[]
+      valetToken: string
+      url: string
+    },
+  ): Promise<'success' | 'failed'> {
+    const backupsDir = await this.getFilesBackupsLocation()
+
+    const fileDir = `${backupsDir}/${uuid}`
+    const metaFilePath = `${fileDir}/${FileBackupsConstantsV1.MetadataFileName}`
+    const binaryPath = `${fileDir}/${FileBackupsConstantsV1.BinaryFileName}`
+
+    await ensureDirectoryExists(fileDir)
+
+    await writeFile(metaFilePath, metaFile)
+
+    const downloader = new FileDownloader(
+      downloadRequest.chunkSizes,
+      downloadRequest.valetToken,
+      downloadRequest.url,
+      binaryPath,
+    )
+
+    const result = await downloader.run()
+
+    if (result === 'success') {
+      const mapping = await this.getFilesBackupsMappingFile()
+
+      mapping.files[uuid] = {
+        backedUpOn: new Date(),
+        absolutePath: fileDir,
+        relativePath: uuid,
+        metadataFileName: FileBackupsConstantsV1.MetadataFileName,
+        binaryFileName: FileBackupsConstantsV1.BinaryFileName,
+        version: FileBackupsConstantsV1.Version,
+      }
+
+      await this.saveFilesBackupsMappingFile(mapping)
+    }
+
+    return result
+  }
+}

app/javascripts/Main/FileBackups/FileDownloader.ts

@@ -0,0 +1,54 @@
+import { WriteStream, createWriteStream } from 'fs'
+import { downloadData } from './FileNetworking'
+
+export class FileDownloader {
+  writeStream: WriteStream
+
+  constructor(private chunkSizes: number[], private valetToken: string, private url: string, filePath: string) {
+    this.writeStream = createWriteStream(filePath, { flags: 'a' })
+  }
+
+  public async run(): Promise<'success' | 'failed'> {
+    const result = await this.downloadChunk(0, 0)
+
+    this.writeStream.close()
+
+    return result
+  }
+
+  private async downloadChunk(chunkIndex = 0, contentRangeStart: number): Promise<'success' | 'failed'> {
+    const pullChunkSize = this.chunkSizes[chunkIndex]
+
+    const headers = {
+      'x-valet-token': this.valetToken,
+      'x-chunk-size': pullChunkSize.toString(),
+      range: `bytes=${contentRangeStart}-`,
+    }
+
+    const response = await downloadData(this.writeStream, this.url, headers)
+
+    if (!String(response.status).startsWith('2')) {
+      return 'failed'
+    }
+
+    const contentRangeHeader = response.headers['content-range'] as string
+    if (!contentRangeHeader) {
+      return 'failed'
+    }
+
+    const matches = contentRangeHeader.match(/(^[a-zA-Z][\w]*)\s+(\d+)\s?-\s?(\d+)?\s?\/?\s?(\d+|\*)?/)
+    if (!matches || matches.length !== 5) {
+      return 'failed'
+    }
+
+    const rangeStart = +matches[2]
+    const rangeEnd = +matches[3]
+    const totalSize = +matches[4]
+
+    if (rangeEnd < totalSize - 1) {
+      return this.downloadChunk(++chunkIndex, rangeStart + pullChunkSize)
+    }
+
+    return 'success'
+  }
+}

app/javascripts/Main/FileBackups/FileNetworking.ts

@@ -0,0 +1,22 @@
+import { WriteStream } from 'fs'
+import axios, { AxiosResponseHeaders, AxiosRequestHeaders } from 'axios'
+
+export async function downloadData(
+  writeStream: WriteStream,
+  url: string,
+  headers: AxiosRequestHeaders,
+): Promise<{
+  headers: AxiosResponseHeaders
+  status: number
+}> {
+  const response = await axios.get(url, {
+    responseType: 'arraybuffer',
+    headers: headers,
+  })
+
+  if (String(response.status).startsWith('2')) {
+    writeStream.write(response.data)
+  }
+
+  return { headers: response.headers, status: response.status }
+}

app/javascripts/Main/Packages/PackageManager.ts

@@ -34,7 +34,8 @@ class MappingFileHandler {
     let mapping: MappingFile
 
     try {
-      mapping = await readJSONFile<MappingFile>(Paths.extensionsMappingJson)
+      const result = await readJSONFile<MappingFile>(Paths.extensionsMappingJson)
+      mapping = result || {}
     } catch (error: any) {
       /**
        * Mapping file might be absent (first start, corrupted data)
@@ -82,6 +83,9 @@ class MappingFileHandler {
     const paths = pathsForComponent(component)
     const packagePath = path.join(paths.absolutePath, 'package.json')
     const response = await readJSONFile<{ version: string }>(packagePath)
+    if (!response) {
+      return ''
+    }
     this.set(component.uuid, paths.relativePath, response.version)
     return response.version
   }

app/javascripts/Main/Remote/RemoteBridge.ts

@@ -11,6 +11,7 @@ import { PackageManagerInterface, Component } from '../Packages/PackageManagerIn
 import { SearchManagerInterface } from '../Search/SearchManagerInterface'
 import { RemoteDataInterface } from './DataInterface'
 import { MenuManagerInterface } from '../Menus/MenuManagerInterface'
+import { FileBackupsDevice, FileBackupsMapping } from '@web/Device/DesktopSnjsExports'
 
 /**
  * Read https://github.com/electron/remote to understand how electron/remote works.
@@ -25,6 +26,7 @@ export class RemoteBridge implements CrossProcessBridge {
     private search: SearchManagerInterface,
     private data: RemoteDataInterface,
     private menus: MenuManagerInterface,
+    private fileBackups: FileBackupsDevice,
   ) {}
 
   get exposableValue(): CrossProcessBridge {
@@ -53,6 +55,14 @@ export class RemoteBridge implements CrossProcessBridge {
       onSearch: this.onSearch.bind(this),
       onInitialDataLoad: this.onInitialDataLoad.bind(this),
       destroyAllData: this.destroyAllData.bind(this),
+      getFilesBackupsMappingFile: this.getFilesBackupsMappingFile.bind(this),
+      saveFilesBackupsFile: this.saveFilesBackupsFile.bind(this),
+      isFilesBackupsEnabled: this.isFilesBackupsEnabled.bind(this),
+      enableFilesBackups: this.enableFilesBackups.bind(this),
+      disableFilesBackups: this.disableFilesBackups.bind(this),
+      changeFilesBackupsLocation: this.changeFilesBackupsLocation.bind(this),
+      getFilesBackupsLocation: this.getFilesBackupsLocation.bind(this),
+      openFilesBackupsLocation: this.openFilesBackupsLocation.bind(this),
     }
   }
 
@@ -151,4 +161,44 @@ export class RemoteBridge implements CrossProcessBridge {
   displayAppMenu() {
     this.menus.popupMenu()
   }
+
+  getFilesBackupsMappingFile(): Promise<FileBackupsMapping> {
+    return this.fileBackups.getFilesBackupsMappingFile()
+  }
+
+  saveFilesBackupsFile(
+    uuid: string,
+    metaFile: string,
+    downloadRequest: {
+      chunkSizes: number[]
+      valetToken: string
+      url: string
+    },
+  ): Promise<'success' | 'failed'> {
+    return this.fileBackups.saveFilesBackupsFile(uuid, metaFile, downloadRequest)
+  }
+
+  public isFilesBackupsEnabled(): Promise<boolean> {
+    return this.fileBackups.isFilesBackupsEnabled()
+  }
+
+  public enableFilesBackups(): Promise<void> {
+    return this.fileBackups.enableFilesBackups()
+  }
+
+  public disableFilesBackups(): Promise<void> {
+    return this.fileBackups.disableFilesBackups()
+  }
+
+  public changeFilesBackupsLocation(): Promise<string | undefined> {
+    return this.fileBackups.changeFilesBackupsLocation()
+  }
+
+  public getFilesBackupsLocation(): Promise<string> {
+    return this.fileBackups.getFilesBackupsLocation()
+  }
+
+  public openFilesBackupsLocation(): Promise<void> {
+    return this.fileBackups.openFilesBackupsLocation()
+  }
 }