@milaboratories/pl-drivers 1.3.25 → 1.4.0

package/src/drivers/download_blob.test.ts

@@ -1,21 +1,22 @@
-import * as fsp from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { ConsoleLoggerAdapter, HmacSha256Signer } from '@milaboratories/ts-helpers';
+import { expect, test } from '@jest/globals';
 import {
+  FieldId,
+  FieldRef,
+  jsonToData,
   PlClient,
   PlTransaction,
-  TestHelpers,
-  jsonToData,
-  FieldRef,
   poll,
   PollTxAccessor,
-  BasicResourceData,
-  FieldId
+  TestHelpers
 } from '@milaboratories/pl-client';
+import { ConsoleLoggerAdapter, HmacSha256Signer } from '@milaboratories/ts-helpers';
+import * as fsp from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
 import { scheduler } from 'node:timers/promises';
-import { createDownloadClient, createLogsClient } from '../clients/helpers';
-import { DownloadDriver, OnDemandBlobResourceSnapshot } from './download_and_logs_blob';
+import { createDownloadClient, createLogsClient } from '../clients/constructors';
+import { DownloadDriver } from './download_blob';
+import { OnDemandBlobResourceSnapshot } from './types';
 
 const fileName = 'answer_to_the_ultimate_question.txt';
 

package/src/drivers/{download_and_logs_blob.ts → download_blob.ts}

@@ -5,40 +5,7 @@ import {
   ComputableStableDefined,
   Watcher
 } from '@milaboratories/computable';
-import { bigintToResourceId, ResourceId } from '@milaboratories/pl-client';
-import {
-  CallersCounter,
-  MiLogger,
-  TaskProcessor,
-  Signer,
-  ValueOrError
-} from '@milaboratories/ts-helpers';
-import * as fsp from 'node:fs/promises';
-import * as fs from 'fs';
-import * as path from 'node:path';
-import { Writable } from 'node:stream';
-import { ClientDownload, UnknownStorageError, WrongLocalFileUrl } from '../clients/download';
-import { ClientLogs } from '../clients/logs';
-import * as helper from './helpers/helpers';
-import * as readline from 'node:readline/promises';
-import Denque from 'denque';
-import * as os from 'node:os';
-import { FilesCache } from './helpers/files_cache';
-import { randomUUID } from 'node:crypto';
-import { buffer } from 'node:stream/consumers';
-import { Readable } from 'node:stream';
-import {
-  InferSnapshot,
-  ResourceInfo,
-  PlTreeEntry,
-  ResourceWithMetadata,
-  rsSchema,
-  makeResourceSnapshot,
-  treeEntryToResourceWithMetadata,
-  ResourceSnapshot,
-  treeEntryToResourceInfo,
-  isPlTreeEntry
-} from '@milaboratories/pl-tree';
+import { ResourceId, ResourceType } from '@milaboratories/pl-client';
 import {
   AnyLogHandle,
   BlobDriver,
@@ -49,20 +16,41 @@ import {
   RemoteBlobHandleAndSize,
   StreamingApiResponse
 } from '@milaboratories/pl-model-common';
-import { dataToHandle, handleToData, isReadyLogHandle } from './logs';
-import { z } from 'zod';
-import { NetworkError400 } from '../helpers/download';
-
-/** ResourceSnapshot that can be passed to OnDemandBlob */
-export const OnDemandBlobResourceSnapshot = rsSchema({
-  kv: {
-    'ctl/file/blobInfo': z.object({
-      sizeBytes: z.coerce.number()
-    })
-  }
-});
-
-export type OnDemandBlobResourceSnapshot = InferSnapshot<typeof OnDemandBlobResourceSnapshot>;
+import {
+  isPlTreeEntry,
+  makeResourceSnapshot,
+  PlTreeEntry,
+  ResourceInfo,
+  ResourceSnapshot,
+  treeEntryToResourceInfo
+} from '@milaboratories/pl-tree';
+import { CallersCounter, MiLogger, Signer, TaskProcessor } from '@milaboratories/ts-helpers';
+import Denque from 'denque';
+import * as fs from 'fs';
+import { randomUUID } from 'node:crypto';
+import * as fsp from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as readline from 'node:readline/promises';
+import { Readable, Writable } from 'node:stream';
+import { buffer } from 'node:stream/consumers';
+import { ClientDownload } from '../clients/download';
+import { ClientLogs } from '../clients/logs';
+import { DownloadBlobTask, nonRecoverableError } from './download_blob_task';
+import { FilesCache } from './helpers/files_cache';
+import {
+  isLocalBlobHandle,
+  newLocalHandle,
+  parseLocalHandle
+} from './helpers/download_local_handle';
+import { getSize, OnDemandBlobResourceSnapshot } from './types';
+import {
+  isRemoteBlobHandle,
+  newRemoteHandle,
+  parseRemoteHandle
+} from './helpers/download_remote_handle';
+import { getResourceInfoFromLogHandle, newLogHandle } from './helpers/logs_handle';
+import { Updater, WrongResourceTypeError } from './helpers/helpers';
 
 export type DownloadDriverOps = {
   /**
@@ -82,11 +70,11 @@ export type DownloadDriverOps = {
  * and notifies every watcher when a file were downloaded. */
 export class DownloadDriver implements BlobDriver {
   /** Represents a Resource Id to the path of a blob as a map. */
-  private idToDownload: Map<ResourceId, Download> = new Map();
+  private idToDownload: Map<ResourceId, DownloadBlobTask> = new Map();
 
   /** Writes and removes files to a hard drive and holds a counter for every
    * file that should be kept. */
-  private cache: FilesCache<Download>;
+  private cache: FilesCache<DownloadBlobTask>;
 
   /** Downloads files and writes them to the local dir. */
   private downloadQueue: TaskProcessor;
@@ -113,14 +101,14 @@ export class DownloadDriver implements BlobDriver {
   }
 
   /** Gets a blob by its resource id or downloads a blob and sets it in a cache.*/
-  getDownloadedBlob(
+  public getDownloadedBlob(
     res: ResourceInfo | PlTreeEntry,
     ctx: ComputableCtx
   ): LocalBlobHandleAndSize | undefined;
-  getDownloadedBlob(
+  public getDownloadedBlob(
     res: ResourceInfo | PlTreeEntry
   ): ComputableStableDefined<LocalBlobHandleAndSize>;
-  getDownloadedBlob(
+  public getDownloadedBlob(
     res: ResourceInfo | PlTreeEntry,
     ctx?: ComputableCtx
   ): Computable<LocalBlobHandleAndSize | undefined> | LocalBlobHandleAndSize | undefined {
@@ -137,117 +125,133 @@ export class DownloadDriver implements BlobDriver {
     return result;
   }
 
-  getOnDemandBlob(
-    res: OnDemandBlobResourceSnapshot | PlTreeEntry
-  ): Computable<RemoteBlobHandleAndSize>;
-  getOnDemandBlob(
-    res: OnDemandBlobResourceSnapshot | PlTreeEntry,
-    ctx: ComputableCtx
-  ): RemoteBlobHandleAndSize;
-  getOnDemandBlob(
-    res: OnDemandBlobResourceSnapshot | PlTreeEntry,
-    ctx?: ComputableCtx
-  ): ComputableStableDefined<RemoteBlobHandleAndSize> | RemoteBlobHandleAndSize | undefined {
-    if (ctx === undefined) return Computable.make((ctx) => this.getOnDemandBlob(res, ctx));
-
-    const rInfo: OnDemandBlobResourceSnapshot = isPlTreeEntry(res)
-      ? makeResourceSnapshot(res, OnDemandBlobResourceSnapshot, ctx)
-      : res;
-
-    const callerId = randomUUID();
-    ctx.addOnDestroy(() => this.releaseOnDemandBlob(rInfo.id, callerId));
-
-    const result = this.getOnDemandBlobNoCtx(ctx.watcher, rInfo, callerId);
-
-    return result;
-  }
-
-  public getLocalPath(handle: LocalBlobHandle): string {
-    return localHandleToPath(handle, this.signer);
-  }
-
-  public async getContent(handle: LocalBlobHandle | RemoteBlobHandle): Promise<Uint8Array> {
-    if (isLocalBlobHandle(handle)) return await read(this.getLocalPath(handle));
-
-    if (!isRemoteBlobHandle(handle)) throw new Error('Malformed remote handle');
-
-    const result = remoteHandleToData(handle, this.signer);
-    const { content } = await this.clientDownload.downloadBlob(result);
-
-    return await buffer(content);
-  }
-
   private getDownloadedBlobNoCtx(
     w: Watcher,
     rInfo: ResourceSnapshot,
     callerId: string
   ): LocalBlobHandleAndSize | undefined {
+    validateDownloadableResourceType('getDownloadedBlob', rInfo.type);
+
     let task = this.idToDownload.get(rInfo.id);
 
     if (task === undefined) {
       // schedule the blob downloading
-      const newTask = this.setNewDownloadTask(w, rInfo, callerId);
+      const newTask = this.setNewDownloadTask(rInfo);
       this.downloadQueue.push({
         fn: () => this.downloadBlob(newTask, callerId),
-        recoverableErrorPredicate: (_) => true
+        recoverableErrorPredicate: (e) => !nonRecoverableError(e)
       });
       task = newTask;
     }
 
     task.attach(w, callerId);
     const result = task.getBlob();
-    if (result === undefined) return undefined;
-    if (result.ok) return result.value;
-    throw result.error;
+    if (!result.done) return undefined;
+    if (result.result.ok) return result.result.value;
+    throw result.result.error;
   }
 
-  private setNewDownloadTask(w: Watcher, rInfo: ResourceSnapshot, callerId: string) {
+  private setNewDownloadTask(rInfo: ResourceSnapshot) {
     const fPath = this.getFilePath(rInfo.id);
-    const result = new Download(
+    const result = new DownloadBlobTask(
+      this.logger,
       this.clientDownload,
       rInfo,
       fPath,
-      dataToLocalHandle(fPath, this.signer)
+      newLocalHandle(fPath, this.signer)
     );
     this.idToDownload.set(rInfo.id, result);
 
     return result;
   }
 
-  private async downloadBlob(task: Download, callerId: string) {
+  private async downloadBlob(task: DownloadBlobTask, callerId: string) {
     await task.download();
-    if (task.getBlob()?.ok) this.cache.addCache(task, callerId);
+    const blob = task.getBlob();
+    if (blob.done && blob.result.ok) {
+      this.cache.addCache(task, callerId);
+    }
+  }
+
+  /** Gets on demand blob. */
+  public getOnDemandBlob(
+    res: OnDemandBlobResourceSnapshot | PlTreeEntry
+  ): Computable<RemoteBlobHandleAndSize>;
+  public getOnDemandBlob(
+    res: OnDemandBlobResourceSnapshot | PlTreeEntry,
+    ctx: ComputableCtx
+  ): RemoteBlobHandleAndSize;
+  public getOnDemandBlob(
+    res: OnDemandBlobResourceSnapshot | PlTreeEntry,
+    ctx?: ComputableCtx
+  ): ComputableStableDefined<RemoteBlobHandleAndSize> | RemoteBlobHandleAndSize | undefined {
+    if (ctx === undefined) return Computable.make((ctx) => this.getOnDemandBlob(res, ctx));
+
+    const rInfo: OnDemandBlobResourceSnapshot = isPlTreeEntry(res)
+      ? makeResourceSnapshot(res, OnDemandBlobResourceSnapshot, ctx)
+      : res;
+
+    const callerId = randomUUID();
+    ctx.addOnDestroy(() => this.releaseOnDemandBlob(rInfo.id, callerId));
+
+    // note that the watcher is not needed,
+    // the handler never changes.
+    const result = this.getOnDemandBlobNoCtx(rInfo, callerId);
+
+    return result;
   }
 
   private getOnDemandBlobNoCtx(
-    w: Watcher,
     info: OnDemandBlobResourceSnapshot,
     callerId: string
   ): RemoteBlobHandleAndSize {
+    validateDownloadableResourceType('getOnDemandBlob', info.type);
+
     let blob = this.idToOnDemand.get(info.id);
 
     if (blob === undefined) {
-      blob = new OnDemandBlobHolder(
-        info.kv['ctl/file/blobInfo'].sizeBytes,
-        dataToRemoteHandle(info, this.signer)
-      );
+      blob = new OnDemandBlobHolder(getSize(info), newRemoteHandle(info, this.signer));
       this.idToOnDemand.set(info.id, blob);
     }
 
-    blob.attach(w, callerId);
+    blob.attach(callerId);
 
     return blob.getHandle();
   }
 
+  /** Gets a path from a handle. */
+  public getLocalPath(handle: LocalBlobHandle): string {
+    const { path } = parseLocalHandle(handle, this.signer);
+    return path;
+  }
+
+  /** Gets a content of a blob by a handle. */
+  public async getContent(handle: LocalBlobHandle | RemoteBlobHandle): Promise<Uint8Array> {
+    if (isLocalBlobHandle(handle)) {
+      return await read(this.getLocalPath(handle));
+    }
+    if (isRemoteBlobHandle(handle)) {
+      const result = parseRemoteHandle(handle, this.signer);
+      const { content } = await this.clientDownload.downloadBlob(result);
+
+      return await buffer(content);
+    }
+
+    throw new Error('Malformed remote handle');
+  }
+
   /** Returns all logs and schedules a job that reads remain logs.
    * Notifies when a new portion of the log appeared. */
-  getLastLogs(res: ResourceInfo | PlTreeEntry, lines: number): Computable<string | undefined>;
-  getLastLogs(
+  public getLastLogs(
+    res: ResourceInfo | PlTreeEntry,
+    lines: number
+  ): Computable<string | undefined>;
+  public getLastLogs(
     res: ResourceInfo | PlTreeEntry,
     lines: number,
     ctx: ComputableCtx
   ): Computable<string | undefined>;
-  getLastLogs(
+  public getLastLogs(
     res: ResourceInfo | PlTreeEntry,
     lines: number,
     ctx?: ComputableCtx
@@ -271,10 +275,11 @@ export class DownloadDriver implements BlobDriver {
     lines: number,
     callerId: string
   ): string | undefined {
+    validateDownloadableResourceType('getLastLogs', rInfo.type);
     const blob = this.getDownloadedBlobNoCtx(w, rInfo, callerId);
     if (blob == undefined) return undefined;
 
-    const path = localHandleToPath(blob.handle, this.signer);
+    const { path } = parseLocalHandle(blob.handle, this.signer);
 
     let logGetter = this.idToLastLines.get(rInfo.id);
 
@@ -292,16 +297,16 @@ export class DownloadDriver implements BlobDriver {
 
   /** Returns a last line that has patternToSearch.
    * Notifies when a new line appeared or EOF reached. */
-  getProgressLog(
+  public getProgressLog(
     res: ResourceInfo | PlTreeEntry,
     patternToSearch: string
   ): Computable<string | undefined>;
-  getProgressLog(
+  public getProgressLog(
     res: ResourceInfo | PlTreeEntry,
     patternToSearch: string,
     ctx: ComputableCtx
   ): string | undefined;
-  getProgressLog(
+  public getProgressLog(
     res: ResourceInfo | PlTreeEntry,
     patternToSearch: string,
     ctx?: ComputableCtx
@@ -331,9 +336,11 @@ export class DownloadDriver implements BlobDriver {
     patternToSearch: string,
     callerId: string
   ): string | undefined {
+    validateDownloadableResourceType('getProgressLog', rInfo.type);
+
     const blob = this.getDownloadedBlobNoCtx(w, rInfo, callerId);
     if (blob == undefined) return undefined;
-    const path = localHandleToPath(blob.handle, this.signer);
+    const { path } = parseLocalHandle(blob.handle, this.signer);
 
     let logGetter = this.idToProgressLog.get(rInfo.id);
 
@@ -352,9 +359,9 @@ export class DownloadDriver implements BlobDriver {
 
   /** Returns an Id of a smart object, that can read logs directly from
    * the platform. */
-  getLogHandle(res: ResourceInfo | PlTreeEntry): Computable<AnyLogHandle>;
-  getLogHandle(res: ResourceInfo | PlTreeEntry, ctx: ComputableCtx): AnyLogHandle;
-  getLogHandle(
+  public getLogHandle(res: ResourceInfo | PlTreeEntry): Computable<AnyLogHandle>;
+  public getLogHandle(res: ResourceInfo | PlTreeEntry, ctx: ComputableCtx): AnyLogHandle;
+  public getLogHandle(
     res: ResourceInfo | PlTreeEntry,
     ctx?: ComputableCtx
   ): Computable<AnyLogHandle> | AnyLogHandle {
@@ -366,17 +373,18 @@ export class DownloadDriver implements BlobDriver {
   }
 
   private getLogHandleNoCtx(rInfo: ResourceSnapshot): AnyLogHandle {
-    return dataToHandle(false, rInfo);
+    validateDownloadableResourceType('getLogHandle', rInfo.type);
+    return newLogHandle(false, rInfo);
   }
 
-  async lastLines(
+  public async lastLines(
     handle: ReadyLogHandle,
     lineCount: number,
     offsetBytes?: number, // if 0n, then start from the end.
     searchStr?: string
   ): Promise<StreamingApiResponse> {
     const resp = await this.clientLogs.lastLines(
-      handleToData(handle),
+      getResourceInfoFromLogHandle(handle),
       lineCount,
       BigInt(offsetBytes ?? 0),
       searchStr
@@ -391,14 +399,14 @@ export class DownloadDriver implements BlobDriver {
     };
   }
 
-  async readText(
+  public async readText(
     handle: ReadyLogHandle,
     lineCount: number,
     offsetBytes?: number,
     searchStr?: string
   ): Promise<StreamingApiResponse> {
     const resp = await this.clientLogs.readText(
-      handleToData(handle),
+      getResourceInfoFromLogHandle(handle),
       lineCount,
       BigInt(offsetBytes ?? 0),
       searchStr
@@ -435,11 +443,13 @@ export class DownloadDriver implements BlobDriver {
     } else {
       // The task is still in a downloading queue.
       const deleted = task.counter.dec(callerId);
-      if (deleted) this.removeTask(task, `the task ${task.path} was removed from cache`);
+      if (deleted) {
+        this.removeTask(task, `the task ${task.path} was removed from cache`);
+      }
     }
   }
 
-  private removeTask(task: Download, reason: string) {
+  private removeTask(task: DownloadBlobTask, reason: string) {
     task.abort(reason);
     task.change.markChanged();
     this.idToDownload.delete(task.rInfo.id);
@@ -463,12 +473,12 @@ export class DownloadDriver implements BlobDriver {
   }
 
   private getFilePath(rId: ResourceId): string {
-    return path.resolve(path.join(this.saveDir, String(BigInt(rId))));
+    return path.resolve(this.saveDir, String(BigInt(rId)));
   }
 }
 
+/** Keeps a counter to the on demand handle. */
 class OnDemandBlobHolder {
-  private readonly change = new ChangeSource();
   private readonly counter = new CallersCounter();
 
   constructor(
@@ -476,22 +486,21 @@ class OnDemandBlobHolder {
     private readonly handle: RemoteBlobHandle
   ) {}
 
-  getHandle(): RemoteBlobHandleAndSize {
+  public getHandle(): RemoteBlobHandleAndSize {
     return { handle: this.handle, size: this.size };
   }
 
-  attach(w: Watcher, callerId: string) {
+  public attach(callerId: string) {
     this.counter.inc(callerId);
-    this.change.attachWatcher(w);
   }
 
-  release(callerId: string): boolean {
+  public release(callerId: string): boolean {
     return this.counter.dec(callerId);
   }
 }
 
 class LastLinesGetter {
-  private updater: helper.Updater;
+  private updater: Updater;
   private log: string | undefined;
   private readonly change: ChangeSource = new ChangeSource();
   private error: any | undefined = undefined;
@@ -501,7 +510,7 @@ class LastLinesGetter {
     private readonly lines: number,
     private readonly patternToSearch?: string
   ) {
-    this.updater = new helper.Updater(async () => this.update());
+    this.updater = new Updater(async () => this.update());
   }
 
   getOrSchedule(w: Watcher): {
@@ -538,22 +547,9 @@ class LastLinesGetter {
   }
 }
 
-async function fileOrDirExists(path: string): Promise<boolean> {
-  try {
-    await fsp.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function read(path: string): Promise<Uint8Array> {
-  return await buffer(Readable.toWeb(fs.createReadStream(path)));
-}
-
 /** Gets last lines from a file by reading the file from the top and keeping
  * last N lines in a window queue. */
-function getLastLines(fPath: PathLike, nLines: number, patternToSearch?: string): Promise<string> {
+function getLastLines(fPath: string, nLines: number, patternToSearch?: string): Promise<string> {
   const inStream = fs.createReadStream(fPath);
   const outStream = new Writable();
 
@@ -579,148 +575,16 @@ function getLastLines(fPath: PathLike, nLines: number, patternToSearch?: string)
   });
 }
 
-export class Download {
-  readonly counter = new CallersCounter();
-  readonly change = new ChangeSource();
-  readonly signalCtl = new AbortController();
-  error: any | undefined;
-  done = false;
-  sizeBytes = 0;
-
-  constructor(
-    readonly clientDownload: ClientDownload,
-    readonly rInfo: ResourceSnapshot,
-    readonly path: string,
-    readonly handle: LocalBlobHandle
-  ) {}
-
-  attach(w: Watcher, callerId: string) {
-    this.counter.inc(callerId);
-    if (!this.done) this.change.attachWatcher(w);
-  }
-
-  async download() {
-    try {
-      // TODO: move size bytes inside fileExists check like in download_url.
-      const { content, size } = await this.clientDownload.downloadBlob(this.rInfo);
-
-      if (!(await fileOrDirExists(path.dirname(this.path))))
-        await fsp.mkdir(path.dirname(this.path), { recursive: true });
-
-      // check in case we already have a file by this resource id
-      // in the directory. It can happen when we forgot to call removeAll
-      // in the previous launch.
-      if (await fileOrDirExists(this.path)) {
-        await content.cancel(`the file already existed`); // we don't need the blob
-      } else {
-        const fileToWrite = Writable.toWeb(fs.createWriteStream(this.path));
-        await content.pipeTo(fileToWrite);
-      }
-
-      this.setDone(size);
-    } catch (e: any) {
-      if (
-        e instanceof DownloadAborted ||
-        e instanceof NetworkError400 ||
-        e instanceof UnknownStorageError ||
-        e instanceof WrongLocalFileUrl ||
-        e.code == 'ENOENT' // file that we downloads from was moved or deleted.
-      ) {
-        this.setError(e);
-        // Just in case we were half-way extracting an archive.
-        await fsp.rm(this.path);
-        return;
-      }
-
-      throw e;
-    }
-  }
-
-  getBlob(): ValueOrError<LocalBlobHandleAndSize> | undefined {
-    if (this.done)
-      return {
-        ok: true,
-        value: {
-          handle: this.handle,
-          size: this.sizeBytes
-        }
-      };
-
-    if (this.error)
-      return {
-        ok: false,
-        error: this.error
-      };
-
-    return undefined;
-  }
-
-  private setDone(sizeBytes: number) {
-    this.done = true;
-    this.sizeBytes = sizeBytes;
-    this.change.markChanged();
-  }
-
-  abort(reason: string) {
-    this.signalCtl.abort(new DownloadAborted(reason));
-  }
-
-  private setError(e: any) {
-    this.error = e;
-    this.change.markChanged();
-  }
-}
-
-type PathLike = string;
-
-class DownloadAborted extends Error {}
-
-// https://regex101.com/r/kfnBVX/1
-const localHandleRegex = /^blob\+local:\/\/download\/(?<path>.*)#(?<signature>.*)$/;
-
-function isLocalBlobHandle(handle: string): handle is LocalBlobHandle {
-  return Boolean(handle.match(localHandleRegex));
-}
-
-function localHandleToPath(handle: LocalBlobHandle, signer: Signer): string {
-  const parsed = handle.match(localHandleRegex);
-
-  if (parsed === null) throw new Error(`Local handle is malformed: ${handle}, matches: ${parsed}`);
-
-  const { path, signature } = parsed.groups!;
-
-  signer.verify(path, signature, `Signature verification failed for: ${handle}`);
-
-  return path;
-}
-
-function dataToLocalHandle(path: string, signer: Signer): LocalBlobHandle {
-  return `blob+local://download/${path}#${signer.sign(path)}` as LocalBlobHandle;
-}
-
-// https://regex101.com/r/rvbPZt/1
-const remoteHandleRegex =
-  /^blob\+remote:\/\/download\/(?<content>(?<resourceType>.*)\/(?<resourceVersion>.*)\/(?<resourceId>.*))#(?<signature>.*)$/;
-
-function isRemoteBlobHandle(handle: string): handle is RemoteBlobHandle {
-  return Boolean(handle.match(remoteHandleRegex));
+async function read(path: string): Promise<Uint8Array> {
+  return await buffer(Readable.toWeb(fs.createReadStream(path)));
 }
 
-function remoteHandleToData(handle: RemoteBlobHandle, signer: Signer): ResourceInfo {
-  const parsed = handle.match(remoteHandleRegex);
-  if (parsed === null) throw new Error(`Remote handle is malformed: ${handle}, matches: ${parsed}`);
+function validateDownloadableResourceType(methodName: string, rType: ResourceType) {
+  if (!rType.name.startsWith('Blob/')) {
+    let message = `${methodName}: wrong resource type: ${rType.name}, expected: a resource of type that starts with 'Blob/'.`;
+    if (rType.name == 'Blob')
+      message += ` If it's called from workflow, should a file be exported with 'file.exportFile' function?`;
 
-  const { content, resourceType, resourceVersion, resourceId, signature } = parsed.groups!;
-
-  signer.verify(content, signature, `Signature verification failed for ${handle}`);
-
-  return {
-    id: bigintToResourceId(BigInt(resourceId)),
-    type: { name: resourceType, version: resourceVersion }
-  };
-}
-
-function dataToRemoteHandle(rInfo: OnDemandBlobResourceSnapshot, signer: Signer): RemoteBlobHandle {
-  const content = `${rInfo.type.name}/${rInfo.type.version}/${BigInt(rInfo.id)}`;
-  return `blob+remote://download/${content}#${signer.sign(content)}` as RemoteBlobHandle;
+    throw new WrongResourceTypeError(message);
+  }
 }