@vzn/vx-reapi 0.0.594 → 0.0.595

package/README.md

@@ -223,11 +223,12 @@ through; a Tree file's setuid and setgid bits are dropped.
 ## Artifacts stream
 
 An artifact up to 256 KiB is read whole and sent in one batch, with no
-probe first. Past that the cache layer never holds an artifact whole: `put` digests the file-backed
-`Blob` vx hands it in one pass over its stream, asks `FindMissingBlobs`, and
-uploads from a second pass: past the batch limit (about 4 MiB) the file is
-read `chunkBytes` at a time as the ByteStream write drains, identity-encoded
-(the artifact is zstd already). `get` returns the ByteStream read as a
+probe first. Up to the batch limit (about 4 MiB) it is read whole once,
+probed with `FindMissingBlobs`, and those bytes sent. Past that the cache
+layer never holds an artifact whole: `put` digests the file-backed `Blob`
+vx hands it in one pass over its stream, asks `FindMissingBlobs`, and
+uploads from a second pass, read `chunkBytes` at a time as the ByteStream
+write drains, identity-encoded (the artifact is zstd already). `get` returns the ByteStream read as a
 `Response`, each message taken from the call as vx writes the previous one
 to disk.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx-reapi",
-  "version": "0.0.594",
+  "version": "0.0.595",
   "license": "MIT",
   "description": "Bazel Remote Execution API plugin for vx — remote cache (ActionCache + CAS) against NativeLink, BuildBuddy, Buildbarn or bazel-remote.",
   "keywords": [
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@vzn/vx": "^0.0.594"
+    "@vzn/vx": "^0.0.595"
   },
   "repository": {
     "type": "git",

package/src/cache.ts

@@ -159,32 +159,32 @@ export class ReapiRemoteCache {
   }
 
   /**
-   * A large artifact takes two passes over `body`, never one in memory: the
-   * digest first (the CAS address must be known before the server is asked),
-   * then the upload from a second read of the stream.
+   * An artifact past `writeBlob`'s whole read takes two passes over `body`,
+   * never one in memory: the digest first (the CAS address must be known
+   * before the server is asked), then the upload from a second read of the
+   * stream.
    */
   async put(hash: string, body: Blob, meta: { durationMs: number }): Promise<void> {
-    let digest: Digest
-    if (body.size <= SMALL_PUT_BYTES) {
+    // Read once, and those bytes hashed and sent, wherever `writeBlob` would
+    // read the Blob whole anyway: a second writer of the key renames its
+    // artifact over the file, and two reads sent its bytes under this one's
+    // digest (F-50).
+    const data = body.size <= this.client.wholeWriteBytes ? await body.bytes() : undefined
+    const digest = data === undefined ? await streamedDigestOf(body) : digestOf(data)
+    if (data !== undefined && data.length <= SMALL_PUT_BYTES) {
       // A small artifact is sent in one batch without asking first: the
       // probe was a round trip of its own to save an upload no larger than
       // it (102 → 71 ms per save at 15 ms one-way, F-26). Content-addressed,
       // so a re-send is harmless.
-      // Read once, and those bytes hashed and sent: a second writer of the
-      // key renames its artifact over the file, and two reads sent its bytes
-      // under this one's digest (F-50).
       // A server whose batch limit is smaller refuses it; stream instead.
-      const data = await body.bytes()
-      digest = digestOf(data)
       await this.client
         .batchUpdateBlobs([{ digest, data }])
         .catch(() => this.client.writeBlob(digest, data))
     } else {
-      digest = await streamedDigestOf(body)
       // Upload only what the server lacks: for a large artifact the probe is
       // cheap next to the bytes it can skip.
       const missing = await this.client.findMissingBlobs([digest])
-      if (missing.length > 0) await this.client.writeBlob(digest, body)
+      if (missing.length > 0) await this.client.writeBlob(digest, data ?? body)
     }
     await this.client.updateActionResult(actionDigestFor(hash), {
       exit_code: 0,

package/src/executor.ts

@@ -12,7 +12,14 @@
 import { mkdir, writeFile, chmod, readlink, realpath, rm, symlink, unlink } from 'node:fs/promises'
 import { constants, existsSync } from 'node:fs'
 import path from 'node:path'
-import { executorFallback, isLiteralPattern, isUserError, normalizeGlob, UserError } from '@vzn/vx'
+import {
+  executorFallback,
+  isLiteralPattern,
+  isUserError,
+  normalizeGlob,
+  UserError,
+  withForwardArgs,
+} from '@vzn/vx'
 import type { ExecuteRequest, ExecuteResult, TaskExecutor, TaskPlacement } from '@vzn/vx'
 import {
   buildInputTree,
@@ -1252,12 +1259,9 @@ async function this_readStream(
   return ''
 }
 
-/** Forwarded args are appended shell-quoted, exactly as the local executor does. */
+/** Forwarded args are placed by core's own `withForwardArgs`, as the local executor's are. */
 function fullCommand(req: ExecuteRequest, cdInto: string, projectRel: string): string {
-  const quoted =
-    req.forwardArgs.length === 0
-      ? req.command
-      : `${req.command} ${req.forwardArgs.map((a) => `'${a.replaceAll("'", `'\\''`)}'`).join(' ')}`
+  const command = withForwardArgs(req.command, req.forwardArgs)
   // A remote action gets NO PATH from this machine — sending one would put a
   // host path in the action digest and split every laptop from every runner.
   // But a task's command is normally a package binary (`oxlint`, `tsc`), and
@@ -1285,7 +1289,7 @@ function fullCommand(req: ExecuteRequest, cdInto: string, projectRel: string): s
   return (
     `VX_ROOT=${root}; ${cd}` +
     `export PATH="$VX_ROOT/node_modules/.bin:$PWD/node_modules/.bin:$PATH"; ` +
-    quoted
+    command
   )
 }
 

package/src/wire.ts

@@ -1002,6 +1002,11 @@ export class ReapiClient {
     )
   }
 
+  /** The largest `Blob` `writeBlob` reads whole rather than streams. */
+  get wholeWriteBytes(): number {
+    return this.negotiatedBatchBytes || SAFE_BATCH_BYTES
+  }
+
   /**
    * Upload a blob via ByteStream, chunked at `chunkBytes`, RESUMING an
    * interrupted identity upload from the server's committed offset
@@ -1017,8 +1022,7 @@ export class ReapiClient {
    * zstd artifact already. A Blob under the limit is small enough to read.
    */
   async writeBlob(digest: Digest, source: Uint8Array | Blob): Promise<void> {
-    const streamed =
-      source instanceof Blob && source.size > (this.negotiatedBatchBytes || SAFE_BATCH_BYTES)
+    const streamed = source instanceof Blob && source.size > this.wholeWriteBytes
     const body = source instanceof Blob && !streamed ? await source.bytes() : source
     const compressed = this.compression && body instanceof Uint8Array
     // REAPI carries compression in the RESOURCE NAME: