Method deletePath

src/database/remove.ts:65–103

* First, attempt to delete the path, if the path is big (i.e. exceeds writeSizeLimit of tiny), * it will perform multi-path recursive chunked deletes in rounds. * Each round, it fetches listNumSubPath subPaths and issue batches based on batchSize. * At the end of each round, it adjustes the

(path: string)

   * @return true if this path is small (Does not exceed writeSizeLimit of tiny)
   */
  private async deletePath(path: string): Promise<boolean> {
    if (await this.deleteJobStack.run(() => this.remote.deletePath(path))) {
      return true;
    }
    let listNumSubPath = INITIAL_LIST_NUM_SUB_PATH;
    // The range of batchSize to gradually narrow down.
    let batchSizeLow = 1;
    let batchSizeHigh = MAX_LIST_NUM_SUB_PATH + 1;
    let batchSize = INITIAL_DELETE_BATCH_SIZE;
    while (true) {
      const subPathList = await this.listStack.run(() =>
        this.listRemote.listPath(path, listNumSubPath),
      );
      if (subPathList.length === 0) {
        return false;
      }
      const chunks = chunkList(subPathList, batchSize);
      let nSmallChunks = 0;
      for (const chunk of chunks) {
        if (await this.deleteSubPath(path, chunk)) {
          nSmallChunks += 1;
        }
      }
      // Narrow the batchSize range depending on whether the majority of the chunks are small.
      if (nSmallChunks > chunks.length / 2) {
        batchSizeLow = batchSize;
        batchSize = Math.floor(Math.min(batchSize * 2, (batchSizeHigh + batchSize) / 2));
      } else {
        batchSizeHigh = batchSize;
        batchSize = Math.floor((batchSizeLow + batchSize) / 2);
      }
      // Start with small number of sub paths to learn about an appropriate batchSize.
      if (listNumSubPath * 2 <= MAX_LIST_NUM_SUB_PATH) {
        listNumSubPath = listNumSubPath * 2;
      } else {
        listNumSubPath = Math.floor(MAX_LIST_NUM_SUB_PATH / batchSize) * batchSize;
      }
    }
  }

  /*
   * Similar to deletePath, but delete multiple subpaths at once.