feat: 🎸 add full NFSv4 encoder

Author: streamich

src/nfs/v3/__demos__/tcp-client.ts

@@ -12,7 +12,7 @@ const HOST = '127.0.0.1';
 
 const createTestRequest = (): Nfsv3GetattrRequest => {
   const fhData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
-  return new Nfsv3GetattrRequest(new Nfsv3Fh(new Reader(fhData)));
+  return new Nfsv3GetattrRequest(new Nfsv3Fh(fhData));
 };
 
 const createTestCred = () => {

src/nfs/v4/FullNfsv4Encoder.ts

@@ -0,0 +1,118 @@
+import {Writer} from '@jsonjoy.com/util/lib/buffers/Writer';
+import {Nfsv4Encoder} from './Nfsv4Encoder';
+import {RpcMessageEncoder} from '../../rpc/RpcMessageEncoder';
+import {RmRecordEncoder} from '../../rm/RmRecordEncoder';
+import {Nfsv4Proc, Nfsv4Const} 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 FullNfsv4Encoder<W extends IWriter & IWriterGrowable = IWriter & IWriterGrowable> {
+  protected readonly nfsEncoder: Nfsv4Encoder<W>;
+  protected readonly rpcEncoder: RpcMessageEncoder<W>;
+  protected readonly rmEncoder: RmRecordEncoder<W>;
+
+  constructor(
+    public program: number = Nfsv4Const.PROGRAM,
+    public readonly writer: W = new Writer() as any,
+  ) {
+    this.nfsEncoder = new Nfsv4Encoder(writer);
+    this.rpcEncoder = new RpcMessageEncoder(writer);
+    this.rmEncoder = new RmRecordEncoder(writer);
+  }
+
+  public encodeCall(
+    xid: number,
+    proc: Nfsv4Proc,
+    cred: RpcOpaqueAuth,
+    verf: RpcOpaqueAuth,
+    request: msg.Nfsv4CompoundRequest,
+  ): Uint8Array {
+    this.writeCall(xid, proc, cred, verf, request);
+    return this.writer.flush();
+  }
+
+  public writeCall(
+    xid: number,
+    proc: Nfsv4Proc,
+    cred: RpcOpaqueAuth,
+    verf: RpcOpaqueAuth,
+    request: msg.Nfsv4CompoundRequest,
+  ): void {
+    const writer = this.writer;
+    const rmHeaderPosition = writer.x;
+    writer.x += RM_HEADER_SIZE;
+    this.rpcEncoder.writeCall(xid, Nfsv4Const.PROGRAM, Nfsv4Const.VERSION, proc, cred, verf);
+    this.nfsEncoder.writeCompound(request, true);
+    this.writeRmHeader(rmHeaderPosition, writer.x);
+  }
+
+  public encodeAcceptedReply(
+    xid: number,
+    proc: Nfsv4Proc,
+    verf: RpcOpaqueAuth,
+    response: msg.Nfsv4CompoundResponse,
+  ): Uint8Array {
+    this.writeAcceptedReply(xid, proc, verf, response);
+    return this.writer.flush();
+  }
+
+  public writeAcceptedReply(
+    xid: number,
+    proc: Nfsv4Proc,
+    verf: RpcOpaqueAuth,
+    response: msg.Nfsv4CompoundResponse,
+  ): void {
+    const writer = this.writer;
+    const rmHeaderPosition = writer.x;
+    writer.x += RM_HEADER_SIZE;
+    this.rpcEncoder.writeAcceptedReply(xid, verf, RpcAcceptStat.SUCCESS);
+    this.nfsEncoder.writeCompound(response, 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/v4/README.md

@@ -13,6 +13,112 @@ NFSv4 is a distributed file system protocol that integrates:
 - Client caching and delegations
 - Internationalization support
 
+## `FullNfsv4Encoder`
+
+`FullNfsv4Encoder` is an optimized 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 {FullNfsv4Encoder} from '@jsonjoy.com/json-pack/lib/nfs/v4';
+import {Reader} from '@jsonjoy.com/buffers/lib/Reader';
+import * as msg from '@jsonjoy.com/json-pack/lib/nfs/v4/messages';
+import * as structs from '@jsonjoy.com/json-pack/lib/nfs/v4/structs';
+
+// Create the encoder
+const encoder = new FullNfsv4Encoder();
+
+// Create NFSv4 COMPOUND request
+const fhData = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+const putfh = new msg.Nfsv4PutfhRequest(new structs.Nfsv4Fh(fhData));
+const getattr = new msg.Nfsv4GetattrRequest(new structs.Nfsv4Bitmap([0, 1]));
+const request = new msg.Nfsv4CompoundRequest('getattr', 0, [putfh, getattr]);
+
+// 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
+  Nfsv4Proc.COMPOUND, // Procedure
+  cred, // Credentials
+  verf, // Verifier
+  request, // NFSv4 COMPOUND request
+);
+
+// Send the encoded data over TCP
+socket.write(encoded);
+```
+
+### NFSv4 COMPOUND Operations
+
+NFSv4 uses a COMPOUND-based architecture where multiple operations are bundled into a single RPC call:
+
+```typescript
+// Multi-operation COMPOUND request
+const putfh = new msg.Nfsv4PutfhRequest(new structs.Nfsv4Fh(fhData));
+const lookup = new msg.Nfsv4LookupRequest('file.txt');
+const getfh = new msg.Nfsv4GetfhRequest();
+const read = new msg.Nfsv4ReadRequest(stateid, BigInt(0), 4096);
+
+const request = new msg.Nfsv4CompoundRequest('read-file', 0, [
+  putfh,
+  lookup,
+  getfh,
+  read,
+]);
+
+const encoded = encoder.encodeCall(xid, Nfsv4Proc.COMPOUND, cred, verf, request);
+```
+
+### Comparison with Separate Encoders
+
+Traditional approach (3 copies):
+
+```typescript
+// Step 1: Encode NFS layer
+const nfsEncoded = nfsEncoder.encodeCompound(request, 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);
+```
+
+### Encoding Response Messages
+
+```typescript
+// Create NFSv4 COMPOUND response
+const putfhRes = new msg.Nfsv4PutfhResponse(Nfsv4Stat.NFS4_OK);
+const getattrRes = new msg.Nfsv4GetattrResponse(
+  Nfsv4Stat.NFS4_OK,
+  new msg.Nfsv4GetattrResOk(fattr),
+);
+const response = new msg.Nfsv4CompoundResponse(Nfsv4Stat.NFS4_OK, 'getattr', [
+  putfhRes,
+  getattrRes,
+]);
+
+// Encode the complete NFS reply (RM + RPC + NFS layers)
+const encoded = encoder.encodeAcceptedReply(xid, proc, verf, response);
+```
+
 ## References
 
 - [RFC 7530](https://tools.ietf.org/html/rfc7530): NFSv4 Protocol