feat: 🎸 add full NFS encoder

Author: streamich

src/nfs/v3/FullNfsv3Encoder.ts

@@ -0,0 +1,115 @@
+import {Writer} from '@jsonjoy.com/util/lib/buffers/Writer';
+import {Nfsv3Encoder} from './Nfsv3Encoder';
+import {RpcMessageEncoder} from '../../rpc/RpcMessageEncoder';
+import {RmRecordEncoder} from '../../rm/RmRecordEncoder';
+import {Nfsv3Proc, Nfsv3Const} from './constants';
+import {RpcOpaqueAuth} from '../../rpc/messages';
+import {RpcAcceptStat} from '../../rpc/constants';
+import type * as msg from './messages';
+import type {IWriter, IWriterGrowable} from '@jsonjoy.com/util/lib/buffers';
+
+const MAX_SINGLE_FRAME_SIZE = 0x7fffffff;
+const RM_HEADER_SIZE = 4;
+
+export class FullNfsv3Encoder<W extends IWriter & IWriterGrowable = IWriter & IWriterGrowable> {
+  protected readonly nfsEncoder: Nfsv3Encoder<W>;
+  protected readonly rpcEncoder: RpcMessageEncoder<W>;
+  protected readonly rmEncoder: RmRecordEncoder<W>;
+
+  constructor(public program: number = 100003, public readonly writer: W = new Writer() as any) {
+    this.nfsEncoder = new Nfsv3Encoder(writer);
+    this.rpcEncoder = new RpcMessageEncoder(writer);
+    this.rmEncoder = new RmRecordEncoder(writer);
+  }
+
+  public encodeCall(
+    xid: number,
+    proc: Nfsv3Proc,
+    cred: RpcOpaqueAuth,
+    verf: RpcOpaqueAuth,
+    request: msg.Nfsv3Request,
+  ): Uint8Array {
+    this.writeCall(xid, proc, cred, verf, request);
+    return this.writer.flush();
+  }
+
+  public writeCall(
+    xid: number,
+    proc: Nfsv3Proc,
+    cred: RpcOpaqueAuth,
+    verf: RpcOpaqueAuth,
+    request: msg.Nfsv3Request,
+  ): void {
+    const writer = this.writer;
+    const rmHeaderPosition = writer.x;
+    writer.x += RM_HEADER_SIZE;
+    this.rpcEncoder.writeCall(xid, Nfsv3Const.PROGRAM, Nfsv3Const.VERSION, proc, cred, verf);
+    this.nfsEncoder.writeMessage(request, proc, true);
+    this.writeRmHeader(rmHeaderPosition, writer.x);
+  }
+
+  public encodeAcceptedReply(
+    xid: number,
+    proc: Nfsv3Proc,
+    verf: RpcOpaqueAuth,
+    response: msg.Nfsv3Response,
+  ): Uint8Array {
+    this.writeAcceptedReply(xid, proc, verf, response);
+    return this.writer.flush();
+  }
+
+  public writeAcceptedReply(
+    xid: number,
+    proc: Nfsv3Proc,
+    verf: RpcOpaqueAuth,
+    response: msg.Nfsv3Response,
+  ): void {
+    const writer = this.writer;
+    const rmHeaderPosition = writer.x;
+    writer.x += RM_HEADER_SIZE;
+    this.rpcEncoder.writeAcceptedReply(xid, verf, RpcAcceptStat.SUCCESS);
+    this.nfsEncoder.writeMessage(response, proc, false);
+    this.writeRmHeader(rmHeaderPosition, writer.x);
+  }
+
+  public encodeRejectedReply(
+    xid: number,
+    rejectStat: number,
+    mismatchInfo?: {low: number; high: number},
+    authStat?: number,
+  ): Uint8Array {
+    this.writeRejectedReply(xid, rejectStat, mismatchInfo, authStat);
+    return this.writer.flush();
+  }
+
+  public writeRejectedReply(
+    xid: number,
+    rejectStat: number,
+    mismatchInfo?: {low: number; high: number},
+    authStat?: number,
+  ): void {
+    const writer = this.writer;
+    const rmHeaderPosition = writer.x;
+    writer.x += RM_HEADER_SIZE;
+    this.rpcEncoder.writeRejectedReply(xid, rejectStat, mismatchInfo, authStat);
+    this.writeRmHeader(rmHeaderPosition, writer.x);
+  }
+
+  private writeRmHeader(rmHeaderPosition: number, endPosition: number): void {
+    const writer = this.writer;
+    const rmEncoder = this.rmEncoder;
+    const totalSize = endPosition - rmHeaderPosition - RM_HEADER_SIZE;
+    if (totalSize <= MAX_SINGLE_FRAME_SIZE) {
+      const currentX = writer.x;
+      writer.x = rmHeaderPosition;
+      rmEncoder.writeHdr(1, totalSize);
+      writer.x = currentX;
+    } else {
+      const currentX = writer.x;
+      writer.x = rmHeaderPosition;
+      const data = writer.uint8.subarray(rmHeaderPosition + RM_HEADER_SIZE, currentX);
+      writer.reset();
+      rmEncoder.writeRecord(data);
+    }
+  }
+}

src/nfs/v3/README.md

@@ -0,0 +1,66 @@
+## `FullNfsv3Encoder`
+
+`FullNfsv3Encoder` encoder that combines all three protocol layers (RM, RPC, and NFS)
+into a single-pass encoding operation, eliminating intermediate data copying.
+
+### Encoding NFS Requests (Call Messages)
+
+```typescript
+import {FullNfsv3Encoder} from '@jsonjoy.com/json-pack/lib/nfs/v3';
+import {Reader} from '@jsonjoy.com/buffers/lib/Reader';
+import * as msg from '@jsonjoy.com/json-pack/lib/nfs/v3/messages';
+import * as structs from '@jsonjoy.com/json-pack/lib/nfs/v3/structs';
+
+// Create the encoder
+const encoder = new FullNfsv3Encoder();
+
+// Create NFS request
+const fhData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+const request = new msg.Nfsv3GetattrRequest(
+  new structs.Nfsv3Fh(new Reader(fhData))
+);
+
+// Create RPC authentication
+const cred = {
+  flavor: 0,
+  body: new Reader(new Uint8Array()),
+};
+const verf = {
+  flavor: 0,
+  body: new Reader(new Uint8Array()),
+};
+
+// Encode the complete NFS call (RM + RPC + NFS layers)
+const encoded = encoder.encodeCall(
+  12345,                      // XID
+  Nfsv3Proc.GETATTR,         // Procedure
+  cred,                       // Credentials
+  verf,                       // Verifier
+  request                     // NFS request
+);
+
+// Send the encoded data over TCP
+socket.write(encoded);
+```
+
+### Comparison with Separate Encoders
+
+Traditional approach (3 copies):
+
+```typescript
+// Step 1: Encode NFS layer
+const nfsEncoded = nfsEncoder.encodeMessage(request, proc, true);
+
+// Step 2: Encode RPC layer (copies NFS data)
+const rpcEncoded = rpcEncoder.encodeCall(xid, prog, vers, proc, cred, verf, nfsEncoded);
+
+// Step 3: Encode RM layer (copies RPC data)
+const rmEncoded = rmEncoder.encodeRecord(rpcEncoded);
+```
+
+Optimized approach (zero copies):
+
+```typescript
+// Single-pass encoding - writes all layers directly to output buffer
+const encoded = fullEncoder.encodeCall(xid, proc, cred, verf, request);
+```