@milaboratories/pl-drivers 1.3.25 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-drivers",
-  "version": "1.3.25",
+  "version": "1.4.0",
   "description": "Drivers and a low-level clients for log streaming, downloading and uploading files from and to pl",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -26,10 +26,10 @@
     "tar-fs": "^3.0.6",
     "undici": "^6.21.0",
     "zod": "^3.23.8",
-    "@milaboratories/ts-helpers": "^1.1.1",
-    "@milaboratories/computable": "^2.3.2",
-    "@milaboratories/pl-tree": "^1.4.16",
-    "@milaboratories/pl-client": "^2.6.1",
+    "@milaboratories/ts-helpers": "^1.1.2",
+    "@milaboratories/pl-tree": "^1.4.18",
+    "@milaboratories/computable": "^2.3.3",
+    "@milaboratories/pl-client": "^2.6.3",
     "@milaboratories/pl-model-common": "^1.8.0"
   },
   "devDependencies": {

package/src/clients/constructors.ts

@@ -0,0 +1,54 @@
+import { PlClient } from '@milaboratories/pl-client';
+import { MiLogger } from '@milaboratories/ts-helpers';
+import { GrpcTransport } from '@protobuf-ts/grpc-transport';
+import { Dispatcher } from 'undici';
+import { ClientDownload } from './download';
+import { ClientLogs } from './logs';
+import { ClientProgress } from './progress';
+import { ClientUpload } from './upload';
+import { ClientLs } from './ls_api';
+import { LocalStorageProjection } from '../drivers/types';
+
+export function createDownloadClient(
+  logger: MiLogger,
+  client: PlClient,
+  localProjections: LocalStorageProjection[]
+) {
+  return client.getDriver({
+    name: 'DownloadBlob',
+    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
+      new ClientDownload(grpcTransport, httpDispatcher, logger, localProjections)
+  });
+}
+
+export function createLogsClient(client: PlClient, logger: MiLogger) {
+  return client.getDriver({
+    name: 'StreamLogs',
+    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
+      new ClientLogs(grpcTransport, httpDispatcher, logger)
+  });
+}
+
+export function createUploadProgressClient(client: PlClient, logger: MiLogger) {
+  return client.getDriver({
+    name: 'UploadProgress',
+    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
+      new ClientProgress(grpcTransport, httpDispatcher, client, logger)
+  });
+}
+
+export function createUploadBlobClient(client: PlClient, logger: MiLogger) {
+  return client.getDriver({
+    name: 'UploadBlob',
+    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
+      new ClientUpload(grpcTransport, httpDispatcher, client, logger)
+  });
+}
+
+export function createLsFilesClient(client: PlClient, logger: MiLogger) {
+  return client.getDriver({
+    name: 'LsFiles',
+    init: (_client: PlClient, grpcTransport: GrpcTransport, _httpDispatcher: Dispatcher) =>
+      new ClientLs(grpcTransport, logger)
+  });
+}

package/src/clients/download.test.ts

@@ -6,7 +6,7 @@ import { ConsoleLoggerAdapter } from '@milaboratories/ts-helpers';
 import { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import { Dispatcher } from 'undici';
 import { text } from 'node:stream/consumers';
-import { ClientDownload, parseLocalFileUrl } from '../clients/download';
+import { ClientDownload, getFullPath, parseLocalUrl } from '../clients/download';
 import { test, expect } from '@jest/globals';
 
 test('should parse local file url even on Windows', () => {
@@ -15,12 +15,15 @@ test('should parse local file url even on Windows', () => {
   const expectedFullPath =
     'C:\\Users\\test\\67z\\2vy\\65i\\67z2vy65i0xwhjwsfsef_ex3k3hxe7qdc2cvtdfkdnhdp9kwlt7-7dmcy0kthe6u.json';
 
-  const got = parseLocalFileUrl(url, new Map([['main', 'C:\\Users\\test']])).replace(
-    path.sep,
-    '\\'
-  ); // for testing on *nix systems
+  const got = parseLocalUrl(url);
 
-  expect(got).toEqual(expectedFullPath);
+  const fullPath = getFullPath(
+    got.storageId,
+    new Map([['main', 'C:\\Users\\test']]),
+    got.relativePath
+  ).replace(path.sep, '\\'); // for testing on *nix systems
+
+  expect(fullPath).toEqual(expectedFullPath);
 });
 
 test('client download from a local file', async () => {

package/src/clients/download.ts

@@ -1,33 +1,27 @@
-import { Readable } from 'node:stream';
+import { addRTypeToMetadata } from '@milaboratories/pl-client';
+import { ResourceInfo } from '@milaboratories/pl-tree';
+import { MiLogger } from '@milaboratories/ts-helpers';
+import { GrpcTransport } from '@protobuf-ts/grpc-transport';
+import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 import * as fs from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
-import { DownloadClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/downloadapi/protocol.client';
-import { GrpcTransport } from '@protobuf-ts/grpc-transport';
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
-import { MiLogger } from '@milaboratories/ts-helpers';
-import { addRTypeToMetadata } from '@milaboratories/pl-client';
+import { Readable } from 'node:stream';
 import { Dispatcher } from 'undici';
-import {
-  DownloadAPI_GetDownloadURL_HTTPHeader,
-  DownloadAPI_GetDownloadURL_Response
-} from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/downloadapi/protocol';
-import { ResourceInfo } from '@milaboratories/pl-tree';
-import { DownloadHelper, DownloadResponse } from '../helpers/download';
 import { LocalStorageProjection } from '../drivers/types';
+import { DownloadResponse, RemoteFileDownloader } from '../helpers/download';
 import { validateAbsolute } from '../helpers/validate';
-
-const storageProtocol = 'storage://';
-
-export class UnknownStorageError extends Error {}
-
-export class WrongLocalFileUrl extends Error {}
+import { DownloadAPI_GetDownloadURL_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/downloadapi/protocol';
+import { DownloadClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/downloadapi/protocol.client';
+import { toHeadersMap } from './helpers';
 
 /** Gets URLs for downloading from pl-core, parses them and reads or downloads
  * files locally and from the web. */
 export class ClientDownload {
   public readonly grpcClient: DownloadClient;
-  private readonly downloadHelper: DownloadHelper;
+  private readonly remoteFileDownloader: RemoteFileDownloader;
+
+  /** Helps to find a storage root directory by a storage id from URL scheme. */
   private readonly localStorageIdsToRoot: Map<string, string>;
 
   constructor(
@@ -37,80 +31,96 @@ export class ClientDownload {
     /** Pl storages available locally */
     localProjections: LocalStorageProjection[]
   ) {
-    for (const lp of localProjections) if (lp.localPath !== '') validateAbsolute(lp.localPath);
     this.grpcClient = new DownloadClient(this.grpcTransport);
-    this.downloadHelper = new DownloadHelper(httpClient);
-    this.localStorageIdsToRoot = new Map(
-      localProjections.map((lp) => [lp.storageId, lp.localPath])
-    );
+    this.remoteFileDownloader = new RemoteFileDownloader(httpClient);
+    this.localStorageIdsToRoot = newLocalStorageIdsToRoot(localProjections);
   }
 
   close() {}
 
-  async getUrl(
-    { id, type }: ResourceInfo,
-    options?: RpcOptions,
-    signal?: AbortSignal
-  ): Promise<DownloadAPI_GetDownloadURL_Response> {
-    const withAbort = options ?? {};
-    withAbort.abort = signal;
-
-    return await this.grpcClient.getDownloadURL(
-      { resourceId: id },
-      addRTypeToMetadata(type, withAbort)
-    ).response;
-  }
-
   async downloadBlob(
     info: ResourceInfo,
     options?: RpcOptions,
     signal?: AbortSignal
   ): Promise<DownloadResponse> {
-    const { downloadUrl, headers } = await this.getUrl(info, options, signal);
+    const { downloadUrl, headers } = await this.grpcGetDownloadUrl(info, options, signal);
 
-    this.logger.info(`download from url ${downloadUrl}`);
+    this.logger.info(`download blob from url ${downloadUrl}`);
 
-    return this.isLocal(downloadUrl)
+    return isLocal(downloadUrl)
       ? await this.readLocalFile(downloadUrl)
-      : await this.downloadHelper.downloadRemoteFile(
-          downloadUrl,
-          headersFromProto(headers),
-          signal
-        );
+      : await this.remoteFileDownloader.download(downloadUrl, toHeadersMap(headers), signal);
   }
 
-  private isLocal = (url: string) => url.startsWith(storageProtocol);
-
   async readLocalFile(url: string): Promise<DownloadResponse> {
-    const fullPath = parseLocalFileUrl(url, this.localStorageIdsToRoot);
-    const stat = await fsp.stat(fullPath);
-    const size = stat.size;
+    const { storageId, relativePath } = parseLocalUrl(url);
+    const fullPath = getFullPath(storageId, this.localStorageIdsToRoot, relativePath);
 
     return {
       content: Readable.toWeb(fs.createReadStream(fullPath)),
-      size
+      size: (await fsp.stat(fullPath)).size
     };
   }
+
+  private async grpcGetDownloadUrl(
+    { id, type }: ResourceInfo,
+    options?: RpcOptions,
+    signal?: AbortSignal
+  ): Promise<DownloadAPI_GetDownloadURL_Response> {
+    const withAbort = options ?? {};
+    withAbort.abort = signal;
+
+    return await this.grpcClient.getDownloadURL(
+      { resourceId: id },
+      addRTypeToMetadata(type, withAbort)
+    ).response;
+  }
 }
 
-export function parseLocalFileUrl(url: string, localStorageIdsToRoot: Map<string, string>): string {
+export function parseLocalUrl(url: string) {
   const parsed = new URL(url);
   if (parsed.pathname == '')
     throw new WrongLocalFileUrl(`url for local filepath ${url} does not match url scheme`);
 
-  const storageId = parsed.host;
-  const storageRoot = localStorageIdsToRoot.get(storageId);
-  if (storageRoot === undefined)
-    throw new UnknownStorageError(`Unknown storage location: ${storageId}`);
+  return {
+    storageId: parsed.host,
+    relativePath: decodeURIComponent(parsed.pathname.slice(1))
+  };
+}
 
-  const localPath = decodeURIComponent(parsed.pathname.slice(1));
-  const fullPath = storageRoot === '' ? localPath : path.join(storageRoot, localPath);
+export function getFullPath(
+  storageId: string,
+  localStorageIdsToRoot: Map<string, string>,
+  relativePath: string
+) {
+  const root = localStorageIdsToRoot.get(storageId);
+  if (root === undefined) throw new UnknownStorageError(`Unknown storage location: ${storageId}`);
+
+  if (root === '') return relativePath;
+
+  return path.join(root, relativePath);
+}
 
-  return fullPath;
+const storageProtocol = 'storage://';
+function isLocal(url: string) {
+  return url.startsWith(storageProtocol);
 }
 
-export function headersFromProto(
-  headers: DownloadAPI_GetDownloadURL_HTTPHeader[]
-): Record<string, string> {
-  return Object.fromEntries(headers.map(({ name, value }) => [name, value]));
+/** Throws when a local URL have invalid scheme. */
+export class WrongLocalFileUrl extends Error {}
+
+/** Happens when a storage for a local file can't be found.  */
+export class UnknownStorageError extends Error {}
+
+export function newLocalStorageIdsToRoot(projections: LocalStorageProjection[]) {
+  const idToRoot: Map<string, string> = new Map();
+  for (const lp of projections) {
+    // Empty string means no prefix, i.e. any file on this machine can be got from the storage.
+    if (lp.localPath !== '') {
+      validateAbsolute(lp.localPath);
+    }
+    idToRoot.set(lp.storageId, lp.localPath);
+  }
+
+  return idToRoot;
 }

package/src/clients/helpers.ts

@@ -1,54 +1,3 @@
-import { PlClient } from '@milaboratories/pl-client';
-import { MiLogger } from '@milaboratories/ts-helpers';
-import { GrpcTransport } from '@protobuf-ts/grpc-transport';
-import { Dispatcher } from 'undici';
-import { ClientDownload } from './download';
-import { ClientLogs } from './logs';
-import { ClientProgress } from './progress';
-import { ClientUpload } from './upload';
-import { ClientLs } from './ls_api';
-import { LocalStorageProjection } from '../drivers/types';
-
-export function createDownloadClient(
-  logger: MiLogger,
-  client: PlClient,
-  localProjections: LocalStorageProjection[]
-) {
-  return client.getDriver({
-    name: 'DownloadBlob',
-    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
-      new ClientDownload(grpcTransport, httpDispatcher, logger, localProjections)
-  });
-}
-
-export function createLogsClient(client: PlClient, logger: MiLogger) {
-  return client.getDriver({
-    name: 'StreamLogs',
-    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
-      new ClientLogs(grpcTransport, httpDispatcher, logger)
-  });
-}
-
-export function createUploadProgressClient(client: PlClient, logger: MiLogger) {
-  return client.getDriver({
-    name: 'UploadProgress',
-    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
-      new ClientProgress(grpcTransport, httpDispatcher, client, logger)
-  });
-}
-
-export function createUploadBlobClient(client: PlClient, logger: MiLogger) {
-  return client.getDriver({
-    name: 'UploadBlob',
-    init: (_: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher) =>
-      new ClientUpload(grpcTransport, httpDispatcher, client, logger)
-  });
-}
-
-export function createLsFilesClient(client: PlClient, logger: MiLogger) {
-  return client.getDriver({
-    name: 'LsFiles',
-    init: (_client: PlClient, grpcTransport: GrpcTransport, _httpDispatcher: Dispatcher) =>
-      new ClientLs(grpcTransport, logger)
-  });
+export function toHeadersMap(headers: { name: string; value: string }[]): Record<string, string> {
+  return Object.fromEntries(headers.map(({ name, value }) => [name, value]));
 }

package/src/clients/upload.ts

@@ -1,12 +1,14 @@
-import * as fs from 'node:fs/promises';
+import { PlClient, ResourceId, ResourceType, addRTypeToMetadata } from '@milaboratories/pl-client';
+import { ResourceInfo } from '@milaboratories/pl-tree';
+import { MiLogger } from '@milaboratories/ts-helpers';
 import { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
-import { PlClient, addRTypeToMetadata } from '@milaboratories/pl-client';
-import { UploadClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol.client';
-import { MiLogger } from '@milaboratories/ts-helpers';
+import * as fs from 'node:fs/promises';
 import { Dispatcher, request } from 'undici';
 import { uploadapi_GetPartURL_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol';
-import { ResourceInfo } from '@milaboratories/pl-tree';
+import { UploadClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol.client';
+import { toHeadersMap } from './helpers';
+import { IncomingHttpHeaders } from 'undici/types/header';
 
 export class MTimeError extends Error {}
 
@@ -14,6 +16,7 @@ export class UnexpectedEOF extends Error {}
 
 export class NetworkError extends Error {}
 
+/** Happens when the file doesn't exist */
 export class NoFileForUploading extends Error {}
 
 /** Low-level client for grpc uploadapi.
@@ -33,133 +36,164 @@ export class ClientUpload {
 
   close() {}
 
-  public async initUpload({ id, type }: ResourceInfo, options?: RpcOptions): Promise<bigint[]> {
-    const init = await this.grpcClient.init({ resourceId: id }, addRTypeToMetadata(type, options));
-    return this.partsToUpload(init.response);
+  public async initUpload(
+    { id, type }: ResourceInfo,
+    options?: RpcOptions
+  ): Promise<{
+    overall: bigint;
+    toUpload: bigint[];
+  }> {
+    const init = await this.grpcInit(id, type, options);
+    return {
+      overall: init.partsCount,
+      toUpload: this.partsToUpload(init.partsCount, init.uploadedParts)
+    };
   }
 
   public async partUpload(
     { id, type }: ResourceInfo,
     path: string,
-    partNumber: bigint,
-    partsOverall: number,
     expectedMTimeUnix: bigint,
+    partNumber: bigint,
     options?: RpcOptions
   ) {
-    const info = await this.grpcClient.getPartURL(
-      {
-        resourceId: id,
-        partNumber: partNumber,
-        uploadedPartSize: 0n // we update progress as a separate call later.
-      },
-      addRTypeToMetadata(type, options)
-    ).response;
+    const info = await this.grpcGetPartUrl(
+      { id, type },
+      partNumber,
+      0n, // we update progress as a separate call later.
+      options
+    );
 
-    const { chunk, mTime } = await this.readChunk(path, info.chunkStart, info.chunkEnd);
-    if (mTime > expectedMTimeUnix) {
-      throw new MTimeError(
-        'file was modified, expected mtime: ' + expectedMTimeUnix + ', got: ' + mTime + '.'
-      );
-    }
+    const chunk = await readFileChunk(path, info.chunkStart, info.chunkEnd);
+    await checkExpectedMTime(path, expectedMTimeUnix);
 
-    const resp = await request(info.uploadUrl, this.prepareUploadOpts(info, chunk));
+    const {
+      body: rawBody,
+      statusCode,
+      headers
+    } = await request(info.uploadUrl, {
+      dispatcher: this.httpClient,
+      body: chunk,
+      headers: toHeadersMap(info.headers),
+      method: info.method.toUpperCase() as Dispatcher.HttpMethod
+    });
 
-    const body = await resp.body.text();
-    this.logger.info(
-      `uploaded chunk ${partNumber} from ${partsOverall} of resource: ${id},` +
-        ` response: '${body.toString()}', ` +
-        `status code: ${resp.statusCode}`
-    );
+    // always read the body for resources to be garbage collected.
+    const body = await rawBody.text();
+    checkStatusCodeOk(statusCode, body, headers, info);
+
+    await this.grpcUpdateProgress({ id, type }, info.chunkEnd - info.chunkStart, options);
+  }
+
+  public async finalize(info: ResourceInfo, options?: RpcOptions) {
+    return await this.grpcFinalize(info, options);
+  }
+
+  /** Calculates parts that need to be uploaded from the parts that were
+   * already uploaded. */
+  private partsToUpload(partsCount: bigint, uploadedParts: bigint[]): bigint[] {
+    const toUpload: bigint[] = [];
+    const uploaded = new Set(uploadedParts);
 
-    if (resp.statusCode != 200) {
-      throw new NetworkError(
-        `response is not ok, status code: ${resp.statusCode},` +
-          ` body: ${body}, headers: ${resp.headers}, url: ${info.uploadUrl}`
-      );
+    for (let i = 1n; i <= partsCount; i++) {
+      if (!uploaded.has(i)) toUpload.push(i);
     }
 
+    return toUpload;
+  }
+
+  private async grpcInit(id: ResourceId, type: ResourceType, options?: RpcOptions) {
+    return await this.grpcClient.init({ resourceId: id }, addRTypeToMetadata(type, options))
+      .response;
+  }
+
+  private async grpcGetPartUrl(
+    { id, type }: ResourceInfo,
+    partNumber: bigint,
+    uploadedPartSize: bigint,
+    options?: RpcOptions
+  ) {
+    return await this.grpcClient.getPartURL(
+      { resourceId: id, partNumber, uploadedPartSize },
+      addRTypeToMetadata(type, options)
+    ).response;
+  }
+
+  private async grpcUpdateProgress(
+    { id, type }: ResourceInfo,
+    bytesProcessed: bigint,
+    options?: RpcOptions
+  ) {
     await this.grpcClient.updateProgress(
       {
         resourceId: id,
-        bytesProcessed: info.chunkEnd - info.chunkStart
+        bytesProcessed
       },
       addRTypeToMetadata(type, options)
-    );
+    ).response;
   }
 
-  public async finalizeUpload({ id, type }: ResourceInfo, options?: RpcOptions) {
-    return await this.grpcClient.finalize({ resourceId: id }, addRTypeToMetadata(type, options));
+  private async grpcFinalize({ id, type }: ResourceInfo, options?: RpcOptions) {
+    return await this.grpcClient.finalize({ resourceId: id }, addRTypeToMetadata(type, options))
+      .response;
   }
+}
 
-  private async readChunk(
-    path: string,
-    chunkStart: bigint,
-    chunkEnd: bigint
-  ): Promise<{ chunk: Buffer; mTime: bigint }> {
-    let f: fs.FileHandle | undefined;
-    try {
-      f = await fs.open(path);
-      const len = Number(chunkEnd - chunkStart);
-      const pos = Number(chunkStart);
-      const b = Buffer.alloc(len);
-      const bytesRead = await this.readBytesFromPosition(f, b, len, pos);
-
-      const stat = await fs.stat(path);
-
-      return {
-        chunk: b.subarray(0, bytesRead),
-        mTime: BigInt(Math.floor(stat.mtimeMs / 1000))
-      };
-    } catch (e: any) {
-      if (e.code == 'ENOENT')
-        throw new NoFileForUploading(`there is no file ${path} for uploading`);
-      throw e;
-    } finally {
-      f?.close();
-    }
+async function readFileChunk(path: string, chunkStart: bigint, chunkEnd: bigint): Promise<Buffer> {
+  let f: fs.FileHandle | undefined;
+  try {
+    f = await fs.open(path);
+    const len = Number(chunkEnd - chunkStart);
+    const pos = Number(chunkStart);
+    const b = Buffer.alloc(len);
+    const bytesRead = await readBytesFromPosition(f, b, len, pos);
+
+    return b.subarray(0, bytesRead);
+  } catch (e: any) {
+    if (e.code == 'ENOENT') throw new NoFileForUploading(`there is no file ${path} for uploading`);
+    throw e;
+  } finally {
+    f?.close();
   }
+}
 
-  /** Read len bytes from a given position. The reason the method exists
-      is that FileHandle.read can read less bytes than it's needed. */
-  async readBytesFromPosition(f: fs.FileHandle, b: Buffer, len: number, position: number) {
-    let bytesReadTotal = 0;
-    while (bytesReadTotal < len) {
-      const { bytesRead } = await f.read(
-        b,
-        bytesReadTotal,
-        len - bytesReadTotal,
-        position + bytesReadTotal
-      );
-      if (bytesRead === 0) {
-        throw new UnexpectedEOF('file ended earlier than expected.');
-      }
-      bytesReadTotal += bytesRead;
+/** Read len bytes from a given position.
+ * Without this, `FileHandle.read` can read less bytes than needed. */
+async function readBytesFromPosition(f: fs.FileHandle, b: Buffer, len: number, position: number) {
+  let bytesReadTotal = 0;
+  while (bytesReadTotal < len) {
+    const { bytesRead } = await f.read(
+      b,
+      bytesReadTotal,
+      len - bytesReadTotal,
+      position + bytesReadTotal
+    );
+    if (bytesRead === 0) {
+      throw new UnexpectedEOF('file ended earlier than expected.');
     }
-
-    return bytesReadTotal;
+    bytesReadTotal += bytesRead;
   }
 
-  /** Calculates parts that need to be uploaded from the parts that were
-   * already uploaded. */
-  private partsToUpload(info: { partsCount: bigint; uploadedParts: bigint[] }): bigint[] {
-    const toUpload: bigint[] = [];
-    const uploaded = new Set(info.uploadedParts);
-
-    for (let i = 1n; i <= info.partsCount; i++) {
-      if (!uploaded.has(i)) toUpload.push(i);
-    }
+  return bytesReadTotal;
+}
 
-    return toUpload;
+async function checkExpectedMTime(path: string, expectedMTimeUnix: bigint) {
+  const mTime = BigInt(Math.floor((await fs.stat(path)).mtimeMs / 1000));
+  if (mTime > expectedMTimeUnix) {
+    throw new MTimeError(`file was modified, expected mtime: ${expectedMTimeUnix}, got: ${mTime}.`);
   }
+}
 
-  private prepareUploadOpts(info: uploadapi_GetPartURL_Response, chunk: Buffer): any {
-    const headers = info.headers.map(({ name, value }) => [name, value]);
-
-    return {
-      dispatcher: this.httpClient,
-      body: chunk,
-      headers: Object.fromEntries(headers),
-      method: info.method.toUpperCase() as Dispatcher.HttpMethod
-    };
+function checkStatusCodeOk(
+  statusCode: number,
+  body: string,
+  headers: IncomingHttpHeaders,
+  info: uploadapi_GetPartURL_Response
+) {
+  if (statusCode != 200) {
+    throw new NetworkError(
+      `response is not ok, status code: ${statusCode},` +
+        ` body: ${body}, headers: ${headers}, url: ${info.uploadUrl}`
+    );
   }
 }