feat: add backup daemon

bin/xu-backup

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+const Backup = require('../dist/backup/Backup').default;
+
+const { argv } = require('yargs')
+  .options({
+    backupdir: {
+      describe: 'Data directory for backups',
+      type: 'string',
+      alias: 'b',
+    },
+    xudir: {
+      describe: 'Data directory for xud',
+      type: 'string',
+      alias: 'x',
+    },
+    loglevel: {
+      describe: 'Verbosity of the logger',
+      type: 'string',
+      alias: 'l',
+    },
+    logpath: {
+      describe: 'Path to the log file',
+      type: 'string',
+    },
+    logdateformat: {
+      describe: 'Format of the logger date',
+      type: 'string',
+    },
+    'lnd.[currency].certpath': {
+      describe: 'Path to the SSL certificate for lnd',
+      type: 'string',
+    },
+    'lnd.[currency].cltvdelta': {
+      describe: 'CLTV delta for the final timelock',
+      type: 'number',
+    },
+    'lnd.[currency].disable': {
+      describe: 'Disable lnd integration',
+      type: 'boolean',
+      default: undefined,
+    },
+    'lnd.[currency].host': {
+      describe: 'Host of the lnd gRPC interface',
+      type: 'string',
+    },
+    'lnd.[currency].macaroonpath': {
+      describe: 'Path of the admin macaroon for lnd',
+      type: 'string',
+    },
+    'lnd.[currency].nomacaroons': {
+      describe: 'Whether to disable macaroons for lnd',
+      type: 'boolean',
+      default: undefined,
+    },
+    'lnd.[currency].port': {
+      describe: 'Port for the lnd gRPC interface',
+      type: 'number',
+    },
+    'raiden.database': {
+      describe: 'Path to the database of Raiden',
+      type: 'string',
+    },
+  });
+
+// delete non-config keys from argv
+delete argv._;
+delete argv.version;
+delete argv.help;
+delete argv.$0;
+
+const backup = new Backup();
+
+backup.start(argv);

lib/Logger.ts

@@ -31,6 +31,7 @@ export enum Context {
   Raiden = 'RAIDEN',
   Swaps = 'SWAPS',
   Http = 'HTTP',
+  Backup= 'BACKUP',
 }
 
 type Loggers = {

lib/backup/Backup.ts

@@ -0,0 +1,156 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { createHash } from 'crypto';
+import Config from '../Config';
+import Logger, { Context } from '../Logger';
+import LndClient from '../lndclient/LndClient';
+
+class Backup {
+  private logger!: Logger;
+  private config = new Config();
+
+  private backupDir!: string;
+
+  private fileWatcher!: fs.FSWatcher;
+  private lndClients: LndClient[] = [];
+
+  public start = async (args: { [argName: string]: any }) => {
+    await this.config.load(args);
+
+    this.backupDir = args.backupdir || this.getDefaultBackupDir();
+
+    this.logger = new Logger({
+      context: Context.Backup,
+      level: this.config.loglevel,
+      filename: this.config.logpath,
+      instanceId: this.config.instanceid,
+      dateFormat: this.config.logdateformat,
+    });
+
+    if (!fs.existsSync(this.backupDir)) {
+      try {
+        fs.mkdirSync(this.backupDir);
+      } catch (error) {
+        this.logger.error(`Could not create backup directory: ${error}`);
+        return;
+      }
+    }
+
+    // Start the LND SCB subscriptions
+    for (const currency in this.config.lnd) {
+      const lndConfig = this.config.lnd[currency]!;
+
+      // Ignore the LND client if it is disabled or not configured
+      if (!lndConfig.disable && Object.entries(lndConfig).length !== 0) {
+        const lndClient = new LndClient(
+          lndConfig,
+          currency,
+          Logger.DISABLED_LOGGER,
+        );
+
+        this.lndClients.push(lndClient);
+
+        await lndClient.init();
+
+        this.logger.verbose(`Writing initial ${lndClient.currency} LND channel backup`);
+
+        const channelBackup = await lndClient.exportAllChannelBackup();
+        this.writeLndBackup(lndClient.currency, channelBackup);
+
+        this.listenToChannelBackups(lndClient);
+
+        lndClient.subscribeChannelBackups();
+        this.logger.verbose(`Listening to ${currency} LND channel backups`);
+      }
+    }
+
+    // Start the Raiden database filewatcher
+    if (args.raiden) {
+      const raidenDb = args.raiden.database;
+
+      if (fs.existsSync(raidenDb)) {
+        let previousRaidenMd5 = '';
+
+        this.logger.verbose('Writing initial Raiden database backup');
+        const { content, hash } = this.readRaidenDatabase(raidenDb);
+
+        previousRaidenMd5 = hash;
+        this.writeBackup('raiden', content);
+
+        this.fileWatcher = fs.watch(raidenDb, { persistent: true, recursive: false }, (event: string) => {
+          if (event === 'change') {
+            const { content, hash } = this.readRaidenDatabase(raidenDb);
+
+            // Compare the MD5 hash of the current content of the file with hash of the content when
+            // it was backed up the last time to ensure that the content of the file has changed
+            if (hash !== previousRaidenMd5) {
+              this.logger.debug('Raiden database changed');
+
+              previousRaidenMd5 = hash;
+              this.writeBackup('raiden', content);
+            }
+          }
+        });
+
+        this.logger.verbose('Listening for changes to the Raiden database');
+      } else {
+        this.logger.error(`Could not find database file of Raiden: ${raidenDb}`);
+      }
+    } else {
+      this.logger.warn('Raiden database file not specified');
+    }
+
+    this.logger.info('Started backup daemon');
+  }
+
+  public stop = async () => {
+    this.fileWatcher.close();
+
+    for (const lndClient of this.lndClients) {
+      await lndClient.close();
+    }
+  }
+
+  private listenToChannelBackups = (lndClient: LndClient) => {
+    lndClient.on('channelBackup', (channelBackup) => {
+      this.logger.debug(`New ${lndClient.currency} channel backup`);
+      this.writeLndBackup(lndClient.currency, channelBackup);
+    });
+  }
+
+  private readRaidenDatabase = (path: string): { content: string, hash: string } => {
+    const content = fs.readFileSync(path);
+
+    return {
+      content: content.toString('utf-8'),
+      hash: createHash('md5').update(content).digest('base64'),
+    };
+  }
+
+  private writeLndBackup = (currency: string, channelBackup: string) => {
+    this.writeBackup(`lnd-${currency}`, channelBackup);
+  }
+
+  private writeBackup = (fileName: string, data: string) => {
+    try {
+      fs.writeFileSync(
+        path.join(this.backupDir, fileName),
+        data,
+      );
+    } catch (error) {
+      this.logger.error(`Could not write backup file: ${error}`);
+    }
+  }
+
+  private getDefaultBackupDir = () => {
+    switch (os.platform()) {
+      case 'win32':
+        return path.join(process.env.LOCALAPPDATA!, 'Xud Backup');
+      default:
+        return path.join(process.env.HOME!, '.xud-backup');
+    }
+  }
+}
+
+export default Backup;

lib/lndclient/LndClient.ts

@@ -28,8 +28,10 @@ interface InvoicesMethodIndex extends InvoicesClient {
 interface LndClient {
   on(event: 'connectionVerified', listener: (newIdentifier?: string) => void): this;
   on(event: 'htlcAccepted', listener: (rHash: string, amount: number) => void): this;
+  on(event: 'channelBackup', listener: (channelBackup: string) => void): this;
   emit(event: 'connectionVerified', newIdentifier?: string): boolean;
   emit(event: 'htlcAccepted', rHash: string, amount: number): boolean;
+  emit(event: 'channelBackup', channelBackup: string): boolean;
 }
 
 /** A class representing a client to interact with lnd. */
@@ -44,6 +46,7 @@ class LndClient extends SwapClient {
   private credentials!: ChannelCredentials;
   private identityPubKey?: string;
   private channelSubscription?: ClientReadableStream<lndrpc.ChannelEventUpdate>;
+  private channelBackupSubscription?: ClientReadableStream<lndrpc.ChanBackupSnapshot>;
   private invoiceSubscriptions = new Map<string, ClientReadableStream<lndrpc.Invoice>>();
 
   /**
@@ -487,6 +490,13 @@ class LndClient extends SwapClient {
     }
   }
 
+  public exportAllChannelBackup = async () => {
+    const request = new lndrpc.ChanBackupExportRequest();
+    const response = await this.unaryCall<lndrpc.ChanBackupExportRequest, lndrpc.ChanBackupSnapshot>('exportAllChannelBackups', request);
+
+    return response.getMultiChanBackup()!.getMultiChanBackup_asB64();
+  }
+
   private addHoldInvoice = (request: lndinvoices.AddHoldInvoiceRequest): Promise<lndinvoices.AddHoldInvoiceResp> => {
     return this.unaryInvoiceCall<lndinvoices.AddHoldInvoiceRequest, lndinvoices.AddHoldInvoiceResp>('addHoldInvoice', request);
   }
@@ -540,6 +550,25 @@ class LndClient extends SwapClient {
     });
   }
 
+  /**
+   * Subscribes to channel backups
+   */
+  public subscribeChannelBackups = () => {
+    if (!this.lightning) {
+      throw errors.LND_IS_UNAVAILABLE(this.status);
+    }
+
+    if (this.channelBackupSubscription) {
+      this.channelBackupSubscription.cancel();
+    }
+
+    this.channelBackupSubscription = this.lightning.subscribeChannelBackups(new lndrpc.ChannelBackupSubscription(), this.meta)
+      .on('data', (backupSnapshot: lndrpc.ChanBackupSnapshot) => {
+        const multiBackup = backupSnapshot.getMultiChanBackup()!;
+        this.emit('channelBackup', multiBackup.getMultiChanBackup_asB64().toString());
+      });
+  }
+
   /**
    * Attempts to close an open channel.
    */