@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/replication/couchdb/LiveSyncReplicator.js

@@ -0,0 +1,1132 @@
+import {
+  VER,
+  MILESTONE_DOCID,
+  REPLICATION_BUSY_TIMEOUT,
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_VERBOSE,
+  DEVICE_ID_PREFERRED,
+  TweakValuesTemplate,
+  DOCID_SYNC_PARAMETERS,
+  DEFAULT_SYNC_PARAMETERS,
+  ProtocolVersions
+} from "../../common/types.js";
+import {
+  resolveWithIgnoreKnownError,
+  globalConcurrencyController,
+  extractObject,
+  wrapException,
+  sizeToHumanReadable,
+  arrayToChunkedArray,
+  parseHeaderValues
+} from "../../common/utils.js";
+import { Logger } from "../../common/logger.js";
+import { checkRemoteVersion, countCompromisedChunks } from "../../pouchdb/negotiation.js";
+import { preprocessOutgoing } from "../../pouchdb/encryption.js";
+import { ensureDatabaseIsCompatible } from "../../pouchdb/LiveSyncDBFunctions.js";
+import {
+  LiveSyncAbstractReplicator
+} from "../LiveSyncAbstractReplicator.js";
+import { shareRunningResult } from "octagonal-wheels/concurrency/lock";
+import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
+import { Trench } from "octagonal-wheels/memory/memutil";
+import { StreamInbox } from "octagonal-wheels/bureau/StreamInbox";
+import {
+  clearHandlers,
+  createSyncParamsHanderForServer,
+  SyncParamsFetchError,
+  SyncParamsNotFoundError,
+  SyncParamsUpdateError
+} from "../SyncParamsHandler.js";
+const currentVersionRange = {
+  min: 0,
+  max: 2400,
+  current: 2
+};
+const selectorOnDemandPull = { selector: { type: { $ne: "leaf" } } };
+async function* genReplication(s, signal) {
+  const inbox = new StreamInbox({ capacity: 1e4 });
+  const push = function(e) {
+    if (signal.aborted || inbox.isClosed) return;
+    if (inbox.post(e)) return;
+    Logger(`Replication event queue is full: ${e[0]}`, LOG_LEVEL_VERBOSE);
+    if (e[0] === "error" || e[0] === "denied") {
+      inbox.error(e[1]);
+    } else if (e[0] === "complete" || e[0] === "finally") {
+      inbox.close();
+    }
+  };
+  void s.on("complete", (result) => push(["complete", result]));
+  void s.on("change", (result) => push(["change", result]));
+  void s.on("active", () => push(["active"]));
+  void s.on("denied", (err) => push(["denied", err]));
+  void s.on("error", (err) => push(["error", err]));
+  void s.on("paused", (err) => push(["paused", err]));
+  void s.then(() => push(["finally"])).catch(() => push(["finally"]));
+  const onAbort = () => inbox.close();
+  signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    const reader = inbox.readable.getReader();
+    while (!signal.aborted) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      yield value;
+    }
+  } catch (ex) {
+    if (ex instanceof Error && ex.name == "AbortError") {
+      Logger(`Replication aborted`, LOG_LEVEL_VERBOSE);
+    } else {
+      throw ex;
+    }
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+    s.cancel();
+    inbox.close();
+  }
+}
+class LiveSyncCouchDBReplicator extends LiveSyncAbstractReplicator {
+  get isChunkSendingSupported() {
+    return true;
+  }
+  isMobile() {
+    return this.env.services.API.isMobile();
+  }
+  constructor(env) {
+    super(env);
+    this.env = env;
+    void this.initializeDatabaseForReplication();
+    this.rawDatabase.on("close", () => {
+      this.closeReplication();
+    });
+  }
+  getInitialSyncParameters(setting) {
+    return Promise.resolve({
+      ...DEFAULT_SYNC_PARAMETERS,
+      protocolVersion: ProtocolVersions.ADVANCED_E2EE
+    });
+  }
+  async getSyncParameters(setting) {
+    try {
+      const downloadedSyncParams = await this.fetchRemoteDocument(setting, DOCID_SYNC_PARAMETERS);
+      if (!downloadedSyncParams) {
+        throw new SyncParamsNotFoundError(`Sync parameters not found on remote server`);
+      }
+      return downloadedSyncParams;
+    } catch (ex) {
+      Logger(`Could not retrieve remote sync parameters`, LOG_LEVEL_INFO);
+      throw SyncParamsFetchError.fromError(ex);
+    }
+  }
+  async putSyncParameters(setting, params) {
+    try {
+      const ret = await this.putRemoteDocument(setting, params);
+      if (ret.ok) {
+        return true;
+      } else {
+        throw new SyncParamsUpdateError(`Could not store remote sync parameters: ${JSON.stringify(ret)}`);
+      }
+    } catch (ex) {
+      Logger(`Could not store remote sync parameters`, LOG_LEVEL_INFO);
+      throw SyncParamsUpdateError.fromError(ex);
+    }
+  }
+  async getReplicationPBKDF2Salt(setting, refresh) {
+    const server = `${setting.couchDB_URI.replace(/\/+$/, "")}/${setting.couchDB_DBNAME}`;
+    const manager = createSyncParamsHanderForServer(server, {
+      put: (params) => this.putSyncParameters(setting, params),
+      get: () => this.getSyncParameters(setting),
+      create: () => this.getInitialSyncParameters(setting)
+    });
+    return await manager.getPBKDF2Salt(refresh);
+  }
+  async migrate(from, to) {
+    Logger(`Database updated from ${from} to ${to}`, LOG_LEVEL_NOTICE);
+    return Promise.resolve(true);
+  }
+  terminateSync() {
+    if (!this.controller) {
+      return;
+    }
+    this.controller.abort();
+    this.controller = void 0;
+  }
+  async openReplication(setting, keepAlive, showResult, ignoreCleanLock) {
+    await this.initializeDatabaseForReplication();
+    if (keepAlive) {
+      void this.openContinuousReplication(setting, showResult, false);
+    } else {
+      return this.openOneShotReplication(setting, showResult, false, "sync", ignoreCleanLock);
+    }
+  }
+  replicationActivated(showResult) {
+    this.syncStatus = "CONNECTED";
+    this.updateInfo();
+    Logger("Replication activated", showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "sync");
+  }
+  async replicationChangeDetected(e, showResult, docSentOnStart, docArrivedOnStart) {
+    try {
+      if (e.direction == "pull") {
+        await this.env.services.replication.parseSynchroniseResult(e.change.docs);
+        this.docArrived += e.change.docs.length;
+      } else {
+        this.docSent += e.change.docs.length;
+      }
+      if (showResult) {
+        const maxPullSeq = this.maxPullSeq;
+        const maxPushSeq = this.maxPushSeq;
+        const lastSyncPullSeq = this.lastSyncPullSeq;
+        const lastSyncPushSeq = this.lastSyncPushSeq;
+        const pushLast = lastSyncPushSeq == 0 ? "" : lastSyncPushSeq >= maxPushSeq ? " (LIVE)" : ` (${maxPushSeq - lastSyncPushSeq})`;
+        const pullLast = lastSyncPullSeq == 0 ? "" : lastSyncPullSeq >= maxPullSeq ? " (LIVE)" : ` (${maxPullSeq - lastSyncPullSeq})`;
+        Logger(
+          `\u2191${this.docSent - docSentOnStart}${pushLast} \u2193${this.docArrived - docArrivedOnStart}${pullLast}`,
+          LOG_LEVEL_NOTICE,
+          "sync"
+        );
+      }
+      this.updateInfo();
+    } catch (ex) {
+      Logger("Replication callback error", LOG_LEVEL_NOTICE, "sync");
+      Logger(ex, LOG_LEVEL_VERBOSE);
+    }
+  }
+  replicationCompleted(showResult) {
+    this.syncStatus = "COMPLETED";
+    this.updateInfo();
+    Logger("Replication completed", showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, showResult ? "sync" : "");
+    this.terminateSync();
+  }
+  replicationDenied(e) {
+    this.syncStatus = "ERRORED";
+    this.updateInfo();
+    this.terminateSync();
+    Logger("Replication denied", LOG_LEVEL_NOTICE, "sync");
+    Logger(e, LOG_LEVEL_VERBOSE);
+  }
+  replicationErrored(e) {
+    this.syncStatus = "ERRORED";
+    this.terminateSync();
+    this.updateInfo();
+    Logger("Replication error", LOG_LEVEL_NOTICE, "sync");
+    Logger(e, LOG_LEVEL_VERBOSE);
+  }
+  replicationPaused() {
+    this.syncStatus = "PAUSED";
+    this.updateInfo();
+    Logger("Replication paused", LOG_LEVEL_VERBOSE, "sync");
+  }
+  async processSync(syncHandler, showResult, docSentOnStart, docArrivedOnStart, syncMode, retrying, reportCancelledAsDone = true) {
+    const controller = new AbortController();
+    if (this.controller) {
+      this.controller.abort();
+    }
+    this.controller = controller;
+    const gen = genReplication(syncHandler, controller.signal);
+    try {
+      for await (const [type, e] of gen) {
+        const releaser = await globalConcurrencyController.tryAcquire(1, REPLICATION_BUSY_TIMEOUT);
+        if (releaser === false) {
+          Logger("Replication stopped for busy.", showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "sync");
+          return "FAILED";
+        }
+        releaser();
+        switch (type) {
+          case "change":
+            if ("direction" in e) {
+              if (e.direction == "pull") {
+                this.lastSyncPullSeq = Number(`${e.change.last_seq}`.split("-")[0]);
+              } else {
+                this.lastSyncPushSeq = Number(`${e.change.last_seq}`.split("-")[0]);
+              }
+              await this.replicationChangeDetected(e, showResult, docSentOnStart, docArrivedOnStart);
+            } else {
+              if (syncMode == "pullOnly") {
+                this.lastSyncPullSeq = Number(`${e.last_seq}`.split("-")[0]);
+                await this.replicationChangeDetected(
+                  { direction: "pull", change: e },
+                  showResult,
+                  docSentOnStart,
+                  docArrivedOnStart
+                );
+              } else if (syncMode == "pushOnly") {
+                this.lastSyncPushSeq = Number(`${e.last_seq}`.split("-")[0]);
+                this.updateInfo();
+                await this.replicationChangeDetected(
+                  { direction: "push", change: e },
+                  showResult,
+                  docSentOnStart,
+                  docArrivedOnStart
+                );
+              }
+            }
+            if (retrying) {
+              if (this.docSent - docSentOnStart + (this.docArrived - docArrivedOnStart) > this.originalSetting.batch_size * 2) {
+                return "NEED_RESURRECT";
+              }
+            }
+            break;
+          case "complete":
+            this.replicationCompleted(showResult);
+            return "DONE";
+          case "active":
+            this.replicationActivated(showResult);
+            break;
+          case "denied":
+            this.replicationDenied(e);
+            return "FAILED";
+          case "error":
+            this.replicationErrored(e);
+            Logger("Replication stopped.", showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "sync");
+            if (this.env.services.remote.hadLastPostFailedBySize) {
+              if (e && e.status == 413) {
+                Logger(
+                  `Something went wrong during synchronisation. Please check the log!`,
+                  LOG_LEVEL_NOTICE
+                );
+                return "FAILED";
+              }
+              return "NEED_RETRY";
+            } else {
+              Logger("Replication error", LOG_LEVEL_NOTICE, "sync");
+              Logger(e, LOG_LEVEL_VERBOSE);
+            }
+            return "FAILED";
+          case "paused":
+            this.replicationPaused();
+            break;
+          case "finally":
+            break;
+          default:
+            Logger(`Unexpected synchronization status:${JSON.stringify(e)}`);
+        }
+      }
+      if (reportCancelledAsDone) {
+        return "DONE";
+      }
+      return "CANCELLED";
+    } catch (ex) {
+      Logger(`Unexpected synchronization exception`);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return "FAILED";
+    } finally {
+      this.terminateSync();
+      this.controller = void 0;
+    }
+  }
+  getEmptyMaxEntry(remoteID) {
+    return {
+      _id: `_local/max_seq_on_chunk-${remoteID}`,
+      maxSeq: 0,
+      remoteID,
+      seqStatusMap: {},
+      _rev: void 0
+    };
+  }
+  async getLastTransferredSeqOfChunks(localDB, remoteID) {
+    const prevMax = {
+      _id: `_local/max_seq_on_chunk-${remoteID}`,
+      maxSeq: 0,
+      remoteID,
+      seqStatusMap: {},
+      _rev: void 0
+    };
+    const previous_max_seq_on_chunk = await wrapException(() => localDB.get(prevMax._id));
+    if (previous_max_seq_on_chunk instanceof Error) {
+      return prevMax;
+    }
+    return previous_max_seq_on_chunk;
+  }
+  async updateMaxTransferredSeqOnChunks(localDB, remoteID, seqStatusMap) {
+    const newMax = {
+      _id: "_local/max_seq_on_chunk",
+      maxSeq: 0,
+      remoteID,
+      seqStatusMap,
+      _rev: void 0
+    };
+    const seqs = Object.keys(seqStatusMap).map((e) => Number(e));
+    let maxSeq = 0;
+    for (const seq of seqs) {
+      if (!seqStatusMap[seq]) {
+        break;
+      }
+      maxSeq = seq;
+    }
+    Logger(`Updating max seq on chunk to ${maxSeq}`, LOG_LEVEL_VERBOSE);
+    newMax.maxSeq = maxSeq;
+    const previous_max_seq_on_chunk = await wrapException(() => localDB.get(newMax._id));
+    if (previous_max_seq_on_chunk instanceof Error) {
+      delete newMax._rev;
+    } else {
+      newMax._rev = previous_max_seq_on_chunk._rev;
+      newMax.seqStatusMap = { ...previous_max_seq_on_chunk.seqStatusMap, ...seqStatusMap };
+    }
+    await wrapException(() => localDB.put(newMax));
+    return newMax;
+  }
+  // Used for sending chunks in bulk before replication.
+  async sendChunks(setting, remoteDB, showResult, fromSeq) {
+    const trench = new Trench(
+      this.env.services.keyValueDB.openSimpleStore("sc-"),
+      false
+    );
+    await trench.eraseAllEphemerals();
+    if (!remoteDB) {
+      const d = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+      if (typeof d === "string") {
+        Logger(
+          this.translate("liveSyncReplicator.couldNotConnectToRemoteDb", { d }),
+          showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+          "fetch"
+        );
+        return false;
+      }
+      remoteDB = d.db;
+    }
+    await this.checkReplicationConnectivity(setting, false, false, false, false);
+    Logger(`Bulk sending chunks to remote database...`, showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "fetch");
+    const remoteMilestone = await remoteDB.get(MILESTONE_DOCID);
+    const remoteID = remoteMilestone?.created ?? 0;
+    const localDB = this.rawDatabase;
+    const te = new TextEncoder();
+    Logger(
+      this.translate("liveSyncReplicator.checkingLastSyncPoint"),
+      showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+      "fetch"
+    );
+    this.syncStatus = "CONNECTED";
+    const limitOneBatch = 250;
+    const prev = await this.getLastTransferredSeqOfChunks(localDB, remoteID);
+    const seq = fromSeq ?? prev.maxSeq;
+    const localScannedDocs = [];
+    const sentMap = {};
+    const diffChunks = localDB.changes({
+      since: seq,
+      live: false,
+      include_docs: true,
+      return_docs: false,
+      selector: { type: "leaf" }
+      // limit: limitOneBatch,
+    }).on("change", (e) => {
+      const numSeq = Number(e.seq);
+      if (prev.seqStatusMap[numSeq]) {
+        return;
+      }
+      localScannedDocs.push({ id: e.id, seq: Number(e.seq) });
+    });
+    await diffChunks;
+    localScannedDocs.sort((a, b) => a.seq - b.seq);
+    const idSeqMap = Object.fromEntries(localScannedDocs.map((e) => [e.id, e.seq]));
+    for (const checkDocs of arrayToChunkedArray(localScannedDocs, limitOneBatch)) {
+      const remoteDocs = await remoteDB.allDocs({ keys: checkDocs.map((e) => e.id), include_docs: false });
+      const remoteDocMap = Object.fromEntries(
+        remoteDocs.rows.map((e) => [e.key, "error" in e ? e.error : e.value])
+      );
+      const sendDocs = checkDocs.filter((e) => remoteDocMap[e.id] == "not_found");
+      const sentDocs = checkDocs.filter((e) => remoteDocMap[e.id] != "not_found");
+      sendDocs.forEach((e) => sentMap[e.seq] = false);
+      sentDocs.forEach((e) => sentMap[e.seq] = true);
+      const sendDocsMap = Object.fromEntries(sendDocs.map((e) => [e.id, e.seq]));
+      if (sendDocs.length > 0) {
+        const localDocs = await localDB.allDocs({ keys: sendDocs.map((e) => e.id), include_docs: true });
+        await trench.queue(
+          "send-chunks",
+          localDocs.rows.filter((e) => "id" in e).map((e) => ({ seq: sendDocsMap[e.id], doc: e.doc, id: e.id }))
+        );
+      }
+    }
+    let bulkDocs = [];
+    let bulkDocsSizeBytes = 0;
+    let bulkDocsSizeCount = 0;
+    let maxSeq = 0;
+    const maxBatchSizeBytes = setting.sendChunksBulkMaxSize * 1024 * 1024;
+    const maxBatchSizeCount = 200;
+    const semaphore = Semaphore(4);
+    let sendingDocs = 0;
+    let sentDocsCount = 0;
+    const sendChunks = async (bulkDocs2, bulkDocsSize, seq2) => {
+      Logger(
+        `Sending ${bulkDocs2.length} (${bulkDocsSize} => ${sizeToHumanReadable(bulkDocsSize)} in plain) chunks to remote database...`,
+        LOG_LEVEL_VERBOSE
+      );
+      const releaser = await semaphore.acquire(1);
+      sendingDocs += bulkDocs2.length;
+      Logger(
+        `\u2191 Uploading chunks 
+${sendingDocs}/(${sentDocsCount} done)`,
+        showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+        "send"
+      );
+      try {
+        const uploadBulkDocTasks = bulkDocs2.map((e) => preprocessOutgoing(e));
+        const uploadBulkDocs = await Promise.all(uploadBulkDocTasks);
+        await remoteDB.bulkDocs(uploadBulkDocs, { new_edits: false });
+        uploadBulkDocs.forEach((e) => sentMap[idSeqMap[e._id]] = true);
+        await this.updateMaxTransferredSeqOnChunks(localDB, remoteID, sentMap);
+        sentDocsCount += bulkDocs2.length;
+        Logger(
+          `\u2191 Uploading chunks 
+${sendingDocs}/(${sentDocsCount} done)`,
+          showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+          "send"
+        );
+      } catch (ex) {
+        Logger("Bulk sending failed.", showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "send");
+        Logger(ex, LOG_LEVEL_VERBOSE);
+        return false;
+      } finally {
+        releaser();
+      }
+      return true;
+    };
+    const tasks = [];
+    do {
+      const nowSendChunks = await trench.dequeue("send-chunks");
+      if (!nowSendChunks || nowSendChunks.length == 0) {
+        break;
+      }
+      for (const chunk of nowSendChunks) {
+        const jsonLength = te.encode(JSON.stringify(chunk.doc)).byteLength + 32;
+        if ((bulkDocsSizeBytes + jsonLength > maxBatchSizeBytes || bulkDocsSizeCount + 1 > maxBatchSizeCount) && bulkDocs.length > 0) {
+          tasks.push(sendChunks([...bulkDocs], bulkDocsSizeBytes, maxSeq));
+          bulkDocs = [];
+          bulkDocsSizeBytes = 0;
+          bulkDocsSizeCount = 0;
+        }
+        bulkDocs.push(chunk.doc);
+        maxSeq = chunk.seq;
+        bulkDocsSizeBytes += jsonLength;
+        bulkDocsSizeCount += 1;
+      }
+      if (bulkDocs.length > 0) {
+        tasks.push(sendChunks([...bulkDocs], bulkDocsSizeBytes, maxSeq));
+      }
+      const results = await Promise.all(
+        tasks.map(async (e) => {
+          try {
+            await e;
+          } catch (ex) {
+            Logger("Bulk sending failed.", showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO, "send");
+            Logger(ex, LOG_LEVEL_VERBOSE);
+            return false;
+          }
+        })
+      );
+      if (results.some((e) => e === false)) {
+        return false;
+      }
+    } while (true);
+    return true;
+  }
+  async openOneShotReplication(setting, showResult, retrying, syncMode, ignoreCleanLock = false) {
+    if (await this.ensurePBKDF2Salt(setting, showResult, !retrying) === false) {
+      return false;
+    }
+    const next = await shareRunningResult("oneShotReplication", async () => {
+      if (this.controller) {
+        Logger(
+          this.translate("liveSyncReplicator.replicationInProgress"),
+          showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+          "sync"
+        );
+        return false;
+      }
+      const localDB = this.rawDatabase;
+      Logger(this.translate("liveSyncReplicator.oneShotSyncBegin", { syncMode }));
+      const ret = await this.checkReplicationConnectivity(setting, false, retrying, showResult, ignoreCleanLock);
+      if (ret === false) {
+        Logger(
+          this.translate("liveSyncReplicator.couldNotConnectToServer"),
+          showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+          "sync"
+        );
+        return false;
+      }
+      this.maxPullSeq = Number(`${ret.info.update_seq}`.split("-")[0]);
+      this.maxPushSeq = Number(`${(await localDB.info()).update_seq}`.split("-")[0]);
+      if (showResult) {
+        Logger(this.translate("liveSyncReplicator.checkingLastSyncPoint"), LOG_LEVEL_NOTICE, "sync");
+      }
+      const { db, syncOptionBase } = ret;
+      this.syncStatus = "STARTED";
+      this.updateInfo();
+      const docArrivedOnStart = this.docArrived;
+      const docSentOnStart = this.docSent;
+      if (!retrying) {
+        this.originalSetting = setting;
+      }
+      this.terminateSync();
+      const syncHandler = syncMode == "sync" ? localDB.sync(db, { ...syncOptionBase }) : syncMode == "pullOnly" ? localDB.replicate.from(db, {
+        ...syncOptionBase,
+        ...setting.readChunksOnline ? selectorOnDemandPull : {}
+      }) : syncMode == "pushOnly" ? localDB.replicate.to(db, { ...syncOptionBase }) : void 0;
+      const syncResult = await this.processSync(
+        syncHandler,
+        showResult,
+        docSentOnStart,
+        docArrivedOnStart,
+        syncMode,
+        retrying,
+        false
+      );
+      if (syncResult == "DONE") {
+        return true;
+      }
+      if (syncResult == "CANCELLED") {
+        return false;
+      }
+      if (syncResult == "FAILED") {
+        return false;
+      }
+      if (syncResult == "NEED_RESURRECT") {
+        this.terminateSync();
+        return async () => await this.openOneShotReplication(
+          this.originalSetting,
+          showResult,
+          false,
+          syncMode,
+          ignoreCleanLock
+        );
+      }
+      if (syncResult == "NEED_RETRY") {
+        const tempSetting = JSON.parse(JSON.stringify(setting));
+        tempSetting.batch_size = Math.ceil(tempSetting.batch_size / 2) + 2;
+        tempSetting.batches_limit = Math.ceil(tempSetting.batches_limit / 2) + 2;
+        if (tempSetting.batch_size <= 5 && tempSetting.batches_limit <= 5) {
+          Logger(
+            this.translate("liveSyncReplicator.cantReplicateLowerValue"),
+            showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+          );
+          return false;
+        } else {
+          Logger(
+            this.translate("liveSyncReplicator.retryLowerBatchSize", {
+              batch_size: tempSetting.batch_size.toString(),
+              batches_limit: tempSetting.batches_limit.toString()
+            }),
+            showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+          );
+          return async () => await this.openOneShotReplication(tempSetting, showResult, true, syncMode, ignoreCleanLock);
+        }
+      }
+      return false;
+    });
+    if (typeof next === "boolean") {
+      return next;
+    }
+    return await next();
+  }
+  replicateAllToServer(setting, showingNotice) {
+    return this.openOneShotReplication(setting, showingNotice ?? false, false, "pushOnly");
+  }
+  replicateAllFromServer(setting, showingNotice) {
+    return this.openOneShotReplication(setting, showingNotice ?? false, false, "pullOnly");
+  }
+  async checkReplicationConnectivity(setting, keepAlive, skipCheck, showResult, ignoreCleanLock = false) {
+    if (setting.versionUpFlash != "") {
+      Logger(this.translate("Replicator.Message.VersionUpFlash"), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+    if (this.controller) {
+      Logger("Another replication running.");
+      return false;
+    }
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      Logger(
+        this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }),
+        showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+      );
+      return false;
+    }
+    if (!skipCheck) {
+      if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
+        Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+        return false;
+      }
+      this.remoteCleaned = false;
+      this.remoteLocked = false;
+      this.remoteLockedAndDeviceNotAccepted = false;
+      this.tweakSettingsMismatched = false;
+      this.preferredTweakValue = void 0;
+      const progress = `${dbRet.info.update_seq}`;
+      const info = {
+        app_version: this.env.services.API.getAppVersion(),
+        plugin_version: this.env.services.API.getPluginVersion(),
+        vault_name: this.env.services.vault.vaultName(),
+        device_name: this.env.services.vault.getVaultName(),
+        progress
+      };
+      const ensure = await ensureDatabaseIsCompatible(dbRet.db, setting, this.nodeid, currentVersionRange, info);
+      if (ensure == "INCOMPATIBLE") {
+        Logger(
+          "The remote database has no compatibility with the running version. Please upgrade the plugin.",
+          LOG_LEVEL_NOTICE
+        );
+        return false;
+      } else if (ensure == "NODE_LOCKED") {
+        Logger(
+          "The remote database has been rebuilt or corrupted since we have synchronized last time. Fetch rebuilt DB, explicit unlocking or chunk clean-up is required.",
+          LOG_LEVEL_NOTICE
+        );
+        this.remoteLockedAndDeviceNotAccepted = true;
+        this.remoteLocked = true;
+        return false;
+      } else if (ensure == "LOCKED") {
+        this.remoteLocked = true;
+      } else if (ensure == "NODE_CLEANED") {
+        if (ignoreCleanLock) {
+          this.remoteLocked = true;
+        } else {
+          Logger(
+            "The remote database has been cleaned up. Fetch rebuilt DB, explicit unlocking or chunk clean-up is required.",
+            LOG_LEVEL_NOTICE
+          );
+          this.remoteLockedAndDeviceNotAccepted = true;
+          this.remoteLocked = true;
+          this.remoteCleaned = true;
+          return false;
+        }
+      } else if (ensure == "OK") {
+      } else if (ensure[0] == "MISMATCHED") {
+        Logger(this.translate("liveSyncReplicator.mismatchedTweakDetected"), LOG_LEVEL_NOTICE);
+        this.tweakSettingsMismatched = true;
+        this.preferredTweakValue = ensure[1];
+        return false;
+      }
+    }
+    const syncOptionBase = {
+      batches_limit: setting.batches_limit,
+      batch_size: setting.batch_size
+    };
+    syncOptionBase.push = {};
+    if (setting.readChunksOnline) {
+      syncOptionBase.pull = { ...selectorOnDemandPull };
+    }
+    const syncOption = keepAlive ? { live: true, retry: true, heartbeat: setting.useTimeouts ? false : 3e4, ...syncOptionBase } : { ...syncOptionBase };
+    return { db: dbRet.db, info: dbRet.info, syncOptionBase, syncOption };
+  }
+  async openContinuousReplication(setting, showResult, retrying) {
+    const next = await shareRunningResult("continuousReplication", async () => {
+      if (this.controller) {
+        Logger(
+          this.translate("liveSyncReplicator.replicationInProgress"),
+          showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+        );
+        return false;
+      }
+      const localDB = this.rawDatabase;
+      Logger(this.translate("liveSyncReplicator.beforeLiveSync"));
+      const caughtUp = await this.env.services.replicator.runFiniteReplicationActivity(
+        () => this.openOneShotReplication(setting, showResult, false, "pullOnly"),
+        { label: "replication" }
+      );
+      if (caughtUp) {
+        Logger(this.translate("liveSyncReplicator.liveSyncBegin"));
+        const ret = await this.checkReplicationConnectivity(setting, true, true, showResult);
+        if (ret === false) {
+          Logger(
+            this.translate("liveSyncReplicator.couldNotConnectToServer"),
+            showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+          );
+          return false;
+        }
+        if (showResult) {
+          Logger(this.translate("liveSyncReplicator.checkingLastSyncPoint"), LOG_LEVEL_NOTICE, "sync");
+        }
+        const { db, syncOption } = ret;
+        this.syncStatus = "STARTED";
+        this.maxPullSeq = Number(`${ret.info.update_seq}`.split("-")[0]);
+        this.maxPushSeq = Number(`${(await localDB.info()).update_seq}`.split("-")[0]);
+        this.updateInfo();
+        const docArrivedOnStart = this.docArrived;
+        const docSentOnStart = this.docSent;
+        if (!retrying) {
+          this.originalSetting = setting;
+        }
+        this.terminateSync();
+        const syncHandler = localDB.sync(db, {
+          ...syncOption
+        });
+        const syncMode = "sync";
+        const syncResult = await this.processSync(
+          syncHandler,
+          showResult,
+          docSentOnStart,
+          docArrivedOnStart,
+          syncMode,
+          retrying
+        );
+        if (syncResult == "DONE") {
+          return true;
+        }
+        if (syncResult == "FAILED") {
+          return false;
+        }
+        if (syncResult == "NEED_RESURRECT") {
+          this.terminateSync();
+          return async () => await this.openContinuousReplication(this.originalSetting, showResult, false);
+        }
+        if (syncResult == "NEED_RETRY") {
+          const tempSetting = JSON.parse(JSON.stringify(setting));
+          tempSetting.batch_size = Math.ceil(tempSetting.batch_size / 2) + 2;
+          tempSetting.batches_limit = Math.ceil(tempSetting.batches_limit / 2) + 2;
+          if (tempSetting.batch_size <= 5 && tempSetting.batches_limit <= 5) {
+            Logger(
+              this.translate("liveSyncReplicator.cantReplicateLowerValue"),
+              showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+            );
+            return false;
+          } else {
+            Logger(
+              this.translate("liveSyncReplicator.retryLowerBatchSize", {
+                batch_size: tempSetting.batch_size.toString(),
+                batches_limit: tempSetting.batches_limit.toString()
+              }),
+              showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO
+            );
+            return async () => await this.openContinuousReplication(tempSetting, showResult, true);
+          }
+        }
+      }
+      return false;
+    });
+    if (typeof next === "boolean") {
+      return next;
+    }
+    return await next();
+  }
+  closeReplication() {
+    if (!this.controller) {
+      return;
+    }
+    this.controller.abort();
+    this.controller = void 0;
+    this.syncStatus = "CLOSED";
+    Logger(this.translate("liveSyncReplicator.replicationClosed"));
+    this.updateInfo();
+  }
+  async tryResetRemoteDatabase(setting) {
+    this.closeReplication();
+    const con = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof con == "string") return;
+    try {
+      await con.db.destroy();
+      Logger(this.translate("liveSyncReplicator.remoteDbDestroyed"), LOG_LEVEL_NOTICE);
+      await this.tryCreateRemoteDatabase(setting);
+    } catch (ex) {
+      Logger(this.translate("liveSyncReplicator.remoteDbDestroyError"), LOG_LEVEL_NOTICE);
+      Logger(ex, LOG_LEVEL_NOTICE);
+    }
+    clearHandlers();
+    await this.ensurePBKDF2Salt(setting, true, false);
+  }
+  async tryCreateRemoteDatabase(setting) {
+    this.closeReplication();
+    const con2 = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof con2 === "string") return;
+    clearHandlers();
+    await this.ensurePBKDF2Salt(setting, true, false);
+    Logger(this.translate("liveSyncReplicator.remoteDbCreatedOrConnected"), LOG_LEVEL_NOTICE);
+  }
+  async markRemoteLocked(setting, locked, lockByClean) {
+    const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
+      return;
+    }
+    if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
+      Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+      return;
+    }
+    const defInitPoint = {
+      _id: MILESTONE_DOCID,
+      type: "milestoneinfo",
+      created: Date.now(),
+      locked,
+      cleaned: lockByClean,
+      accepted_nodes: [this.nodeid],
+      node_chunk_info: { [this.nodeid]: currentVersionRange },
+      node_info: {},
+      tweak_values: {}
+    };
+    const remoteMilestone = {
+      ...defInitPoint,
+      ...await resolveWithIgnoreKnownError(dbRet.db.get(MILESTONE_DOCID), defInitPoint)
+    };
+    remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
+    remoteMilestone.accepted_nodes = [this.nodeid];
+    remoteMilestone.locked = locked;
+    remoteMilestone.cleaned = remoteMilestone.cleaned || lockByClean;
+    if (locked) {
+      Logger(this.translate("liveSyncReplicator.lockRemoteDb"), LOG_LEVEL_NOTICE);
+    } else {
+      Logger(this.translate("liveSyncReplicator.unlockRemoteDb"), LOG_LEVEL_NOTICE);
+    }
+    await dbRet.db.put(remoteMilestone);
+  }
+  async markRemoteResolved(setting) {
+    const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
+      return;
+    }
+    if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
+      Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+      return;
+    }
+    const defInitPoint = {
+      _id: MILESTONE_DOCID,
+      type: "milestoneinfo",
+      created: Date.now(),
+      locked: false,
+      accepted_nodes: [this.nodeid],
+      node_info: {},
+      node_chunk_info: { [this.nodeid]: currentVersionRange },
+      tweak_values: {}
+    };
+    const remoteMilestone = {
+      ...defInitPoint,
+      ...await resolveWithIgnoreKnownError(dbRet.db.get(MILESTONE_DOCID), defInitPoint)
+    };
+    remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
+    remoteMilestone.accepted_nodes = Array.from(/* @__PURE__ */ new Set([...remoteMilestone.accepted_nodes, this.nodeid]));
+    Logger(this.translate("liveSyncReplicator.markDeviceResolved"), LOG_LEVEL_NOTICE);
+    const result = await dbRet.db.put(remoteMilestone);
+    if (result.ok) {
+      Logger(this.translate("liveSyncReplicator.remoteDbMarkedResolved"), LOG_LEVEL_VERBOSE);
+    } else {
+      Logger(this.translate("liveSyncReplicator.couldNotMarkResolveRemoteDb"), LOG_LEVEL_NOTICE);
+    }
+  }
+  connectRemoteCouchDBWithSetting(settings, isMobile, performSetup = false, skipInfo = false) {
+    if (settings.encrypt && settings.passphrase == "" && !settings.permitEmptyPassphrase) {
+      return "Empty passphrases cannot be used without explicit permission";
+    }
+    const customHeaders = parseHeaderValues(settings.couchDB_CustomHeaders);
+    const auth = settings.useJWT ? {
+      jwtAlgorithm: settings.jwtAlgorithm,
+      jwtKey: settings.jwtKey,
+      jwtExpDuration: settings.jwtExpDuration,
+      jwtKid: settings.jwtKid,
+      jwtSub: settings.jwtSub,
+      type: "jwt"
+    } : {
+      username: settings.couchDB_USER,
+      password: settings.couchDB_PASSWORD,
+      type: "basic"
+    };
+    return this.env.services.remote.connect(
+      settings.couchDB_URI.replace(/\/+$/, "") + (settings.couchDB_DBNAME == "" ? "" : "/" + settings.couchDB_DBNAME),
+      auth,
+      settings.disableRequestURI || isMobile,
+      settings.encrypt ? settings.passphrase : false,
+      settings.useDynamicIterationCount,
+      performSetup,
+      skipInfo,
+      settings.enableCompression,
+      customHeaders,
+      settings.useRequestAPI,
+      async () => await this.getReplicationPBKDF2Salt(settings)
+    );
+  }
+  async _ensureConnection(settings, performSetup = false) {
+    const ret = await this.connectRemoteCouchDBWithSetting(settings, this.isMobile(), performSetup, true);
+    if (typeof ret === "string") {
+      throw new Error(`${this.translate("liveSyncReplicator.couldNotConnectToServer")}:${ret}`);
+    }
+    return ret.db;
+  }
+  /**
+   * Fetch a document from the remote database directly.
+   * @param settings RemoteDBSettings for the connection.
+   * @param id Document ID to fetch.
+   * @param db Optional PouchDB instance to use. If provided, it will use this instance instead of creating a new connection (then settings will be ignored).
+   * @returns The fetched document or false if the document does not exist.
+   * @throws {Error} Other errors that may occur during the fetch operation.
+   */
+  async fetchRemoteDocument(settings, id, db) {
+    try {
+      const connDB = db ?? await this._ensureConnection(settings);
+      return await connDB.get(id);
+    } catch (ex) {
+      if (ex && ex.status == 404) {
+        return false;
+      }
+      throw ex;
+    }
+  }
+  /**
+   * Puts a document to the remote database directly
+   * @param settings RemoteDBSettings for the connection.
+   * @param doc Document to put.
+   * @param db Optional PouchDB instance to use. If provided, it will use this instance instead of creating a new connection (then settings will be ignored).
+   * @returns Response from the remote database or false if an error occurred.
+   * @throws {Error} If the document could not be put.
+   */
+  async putRemoteDocument(settings, doc, db) {
+    const connDB = db ?? await this._ensureConnection(settings, true);
+    return await connDB.put(doc);
+  }
+  async fetchRemoteChunks(missingChunks, showResult) {
+    const ret = await this.connectRemoteCouchDBWithSetting(this.currentSettings, this.isMobile(), false, true);
+    if (typeof ret === "string") {
+      Logger(
+        `${this.translate("liveSyncReplicator.couldNotConnectToServer")} ${ret} `,
+        showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+        "fetch"
+      );
+      return false;
+    }
+    const remoteChunks = await ret.db.allDocs({ keys: missingChunks, include_docs: true });
+    if (remoteChunks.rows.some((e) => "error" in e)) {
+      Logger(
+        `Some chunks are not exists both on remote and local database.`,
+        showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO,
+        "fetch"
+      );
+      Logger(`Missing chunks: ${missingChunks.join(",")}`, LOG_LEVEL_VERBOSE);
+      Logger(
+        `Error chunks: ${remoteChunks.rows.filter((e) => "error" in e).map((e) => e.key).join(",")}`,
+        LOG_LEVEL_VERBOSE
+      );
+      return false;
+    }
+    const remoteChunkItems = remoteChunks.rows.map((e) => e.doc);
+    return remoteChunkItems;
+  }
+  async tryConnectRemote(setting, showResult = true) {
+    const db = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof db === "string") {
+      Logger(
+        this.translate("liveSyncReplicator.couldNotConnectTo", {
+          uri: setting.couchDB_URI,
+          name: setting.couchDB_DBNAME,
+          db
+        }),
+        LOG_LEVEL_NOTICE
+      );
+      return false;
+    }
+    Logger(`Connected to ${db.info.db_name} successfully`, LOG_LEVEL_NOTICE);
+    return true;
+  }
+  async resetRemoteTweakSettings(setting) {
+    const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
+      return;
+    }
+    if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
+      Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+      return;
+    }
+    try {
+      const remoteMilestone = await dbRet.db.get(MILESTONE_DOCID);
+      remoteMilestone.tweak_values = {};
+      await dbRet.db.put(remoteMilestone);
+      Logger(`tweak values on the remote database have been cleared`, LOG_LEVEL_VERBOSE);
+    } catch (ex) {
+      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+      throw ex;
+    }
+  }
+  async setPreferredRemoteTweakSettings(setting) {
+    const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
+      return;
+    }
+    if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
+      Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+      return;
+    }
+    try {
+      const remoteMilestone = await dbRet.db.get(MILESTONE_DOCID);
+      remoteMilestone.tweak_values[DEVICE_ID_PREFERRED] = extractObject(TweakValuesTemplate, { ...setting });
+      await dbRet.db.put(remoteMilestone);
+      Logger(`Preferred tweak values has been registered`, LOG_LEVEL_VERBOSE);
+    } catch (ex) {
+      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+      throw ex;
+    }
+  }
+  async getRemotePreferredTweakValues(setting) {
+    const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
+      Logger(this.translate("liveSyncReplicator.remoteDbCorrupted"), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    try {
+      const remoteMilestone = await dbRet.db.get(MILESTONE_DOCID);
+      if (!remoteMilestone) throw new Error("Remote milestone not found");
+      return remoteMilestone?.tweak_values?.[DEVICE_ID_PREFERRED] || false;
+    } catch (ex) {
+      Logger(`Could not retrieve remote milestone`, LOG_LEVEL_NOTICE);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
+  }
+  async compactRemote(setting) {
+    const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    const ret = await dbRet.db.compact({ interval: 1e3 });
+    return ret.ok;
+  }
+  async getRemoteStatus(setting) {
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+      Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    const info = await dbRet.db.info();
+    return {
+      ...info,
+      estimatedSize: info?.sizes?.file || 0
+    };
+  }
+  async countCompromisedChunks(setting = this.currentSettings) {
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+      Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    const compromised = await countCompromisedChunks(dbRet.db);
+    return compromised;
+  }
+  async getConnectedDeviceList(setting = this.currentSettings) {
+    const dbRet = await this.connectRemoteCouchDBWithSetting(setting, this.isMobile(), true);
+    if (typeof dbRet === "string") {
+      const uri = setting.couchDB_URI.replace(/\/+$/, "") + (setting.couchDB_DBNAME == "" ? "" : "/" + setting.couchDB_DBNAME);
+      Logger(this.translate("liveSyncReplicator.couldNotConnectToURI", { uri, dbRet }), LOG_LEVEL_NOTICE);
+      return false;
+    }
+    const milestoneDoc = await dbRet.db.get(MILESTONE_DOCID);
+    if (!milestoneDoc) {
+      Logger("Could not retrieve remote milestone", LOG_LEVEL_NOTICE);
+      return false;
+    }
+    const nodeInfo = milestoneDoc.node_info;
+    const acceptedNodes = milestoneDoc.accepted_nodes || [];
+    return { node_info: nodeInfo, accepted_nodes: acceptedNodes };
+  }
+}
+export {
+  LiveSyncCouchDBReplicator
+};