test: 💍 add LOCK tests

Author: streamich

src/nfs/v4/server/__demos__/README.md

@@ -37,7 +37,7 @@ PORT=8777 npx ts-node src/nfs/v4/server/__demos__/tcp-server.ts
 Then mount an NFSv4 share from another terminal or machine:
 
 ```bash
-mount -t nfs -o vers=4,nfsvers=4,port=8777,mountport=8777,proto=tcp,sec=none 127.0.0.1:/export ~/mnt/test
+mount -t nfs -o vers=4,nfsvers=4,port=8777,mountport=8777,proto=tcp,sec=none,noowners 127.0.0.1:/export ~/mnt/test
 ```
 
 Unmount with:

src/nfs/v4/server/operations/node/Nfsv4OperationsNode.ts

@@ -973,7 +973,7 @@ export class Nfsv4OperationsNode implements Nfsv4Operations {
       if (this.hasConflictingLock(currentPath, locktype, offset, length, existingLockOwnerKey)) {
         const conflictOwner = new struct.Nfsv4LockOwner(BigInt(0), new Uint8Array());
         const denied = new msg.Nfsv4LockResDenied(offset, length, locktype, conflictOwner);
-        return new msg.Nfsv4LockResponse(Nfsv4Stat.NFS4ERR_LOCKED, undefined, denied);
+        return new msg.Nfsv4LockResponse(Nfsv4Stat.NFS4ERR_DENIED, undefined, denied);
       }
       const lockStateid = this.getOrCreateLockStateid(existingLockOwnerKey, currentPath);
       const stateid = lockStateid.incrementAndGetStateid();
@@ -1031,7 +1031,7 @@ export class Nfsv4OperationsNode implements Nfsv4Operations {
     if (this.hasConflictingLock(currentPath, locktype, offset, length, lockOwnerKey)) {
       const conflictOwner = new struct.Nfsv4LockOwner(BigInt(0), new Uint8Array());
       const denied = new msg.Nfsv4LockResDenied(offset, length, locktype, conflictOwner);
-      return new msg.Nfsv4LockResponse(Nfsv4Stat.NFS4ERR_LOCKED, undefined, denied);
+      return new msg.Nfsv4LockResponse(Nfsv4Stat.NFS4ERR_DENIED, undefined, denied);
     }
     let lockOwnerState = this.lockOwners.get(lockOwnerKey);
     if (!lockOwnerState) {
@@ -1073,7 +1073,7 @@ export class Nfsv4OperationsNode implements Nfsv4Operations {
     if (this.hasConflictingLock(currentPath, locktype, offset, length, ownerKey)) {
       const conflictOwner = new struct.Nfsv4LockOwner(BigInt(0), new Uint8Array());
       const denied = new msg.Nfsv4LocktResDenied(offset, length, locktype, conflictOwner);
-      return new msg.Nfsv4LocktResponse(Nfsv4Stat.NFS4ERR_LOCKED, denied);
+      return new msg.Nfsv4LocktResponse(Nfsv4Stat.NFS4ERR_DENIED, denied);
     }
     return new msg.Nfsv4LocktResponse(Nfsv4Stat.NFS4_OK);
   }

src/nfs/v4/server/operations/node/__tests__/LOCK-CONFLICTS.spec.ts

@@ -0,0 +1,101 @@
+import {setupNfsClientServerTestbed} from '../../../__tests__/setup';
+import * as msg from '../../../../messages';
+import {Nfsv4Stat, Nfsv4LockType} from '../../../../constants';
+import {nfs} from '../../../../builder';
+
+/**
+ * Multi-client lock conflict tests based on RFC 7530 Section 9
+ * Tests lock compatibility matrix and conflict resolution
+ */
+describe('Lock conflicts between multiple clients (RFC 7530 §9)', () => {
+  describe('READ lock compatibility (shared locks)', () => {
+    test.todo('should allow multiple READ locks from different clients on same range');
+    test.todo('should allow multiple READ locks from different lock-owners on same range');
+    test.todo('should allow overlapping READ locks');
+  });
+
+  describe('WRITE lock exclusivity', () => {
+    test.todo('should prevent WRITE lock when READ lock held by another client');
+    test.todo('should prevent WRITE lock when WRITE lock held by another client');
+    test.todo('should allow WRITE lock when no conflicting locks exist');
+  });
+
+  describe('READ vs WRITE conflicts', () => {
+    test.todo('should prevent READ lock when WRITE lock held by another client');
+    test.todo('should return NFS4ERR_DENIED for READ when WRITE held');
+    test.todo('should return NFS4ERR_DENIED for WRITE when READ held');
+  });
+
+  describe('WRITE vs WRITE conflicts', () => {
+    test.todo('should prevent WRITE lock when another WRITE lock held');
+    test.todo('should return NFS4ERR_DENIED with conflict details');
+  });
+
+  describe('Lock-owner isolation', () => {
+    test.todo('should isolate locks between different lock-owners');
+    test.todo('should not conflict with own locks from same lock-owner');
+    test.todo('should conflict with locks from different lock-owners');
+  });
+
+  describe('LOCK4denied structure', () => {
+    test.todo('should return correct offset in LOCK4denied');
+    test.todo('should return correct length in LOCK4denied');
+    test.todo('should return correct locktype in LOCK4denied');
+    test.todo('should return lock_owner4 of conflicting lock in LOCK4denied');
+    test.todo('should return approximate values if exact conflict unknown');
+  });
+
+  describe('Non-overlapping locks', () => {
+    test.todo('should allow non-overlapping locks from different clients');
+    test.todo('should allow adjacent locks from different clients');
+  });
+
+  describe('Blocking lock fairness', () => {
+    test.todo('should queue blocking locks from multiple clients');
+    test.todo('should grant locks in order of request');
+    test.todo('should maintain fairness across multiple clients');
+  });
+});
+
+/**
+ * Lease renewal via lock operations based on RFC 7530 Section 9.5
+ */
+describe('Lease renewal via lock operations (RFC 7530 §9.5)', () => {
+  describe('Implicit lease renewal', () => {
+    test.todo('should renew lease on LOCK operation');
+    test.todo('should renew lease on LOCKU operation');
+    test.todo('should renew lease on LOCKT operation');
+    test.todo('should renew all leases for client together');
+  });
+
+  describe('Operations that renew lease', () => {
+    test.todo('should renew lease with valid clientid');
+    test.todo('should renew lease with valid stateid (not special)');
+    test.todo('should not renew lease with anonymous stateid');
+    test.todo('should not renew lease with READ bypass stateid');
+  });
+
+  describe('SETCLIENTID behavior', () => {
+    test.todo('should not renew lease with SETCLIENTID');
+    test.todo('should not renew lease with SETCLIENTID_CONFIRM');
+    test.todo('should drop locking state on client verifier change');
+  });
+
+  describe('Lease expiration prevention', () => {
+    test.todo('should not expire lease during active locking operations');
+    test.todo('should extend lease time on each operation');
+    test.todo('should maintain common expiration time for all client state');
+  });
+
+  describe('Lease time management', () => {
+    test.todo('should update single lease expiration for all state on renewal');
+    test.todo('should allow low-overhead renewal via normal operations');
+    test.todo('should not require explicit RENEW for active clients');
+  });
+
+  describe('Stale state detection', () => {
+    test.todo('should return NFS4ERR_STALE_STATEID after server reboot');
+    test.todo('should return NFS4ERR_STALE_CLIENTID after server reboot');
+    test.todo('should prevent spurious renewals after reboot');
+  });
+});

src/nfs/v4/server/operations/node/__tests__/LOCK-ERRORS.spec.ts

@@ -0,0 +1,168 @@
+import {setupNfsClientServerTestbed} from '../../../__tests__/setup';
+import * as msg from '../../../../messages';
+import {Nfsv4Stat, Nfsv4OpenAccess, Nfsv4OpenDeny, Nfsv4LockType} from '../../../../constants';
+import {nfs} from '../../../../builder';
+
+/**
+ * Comprehensive error condition tests for locking operations
+ * Based on RFC 7530 Sections 9 and 16.10-16.12
+ */
+describe('Lock operation error conditions (RFC 7530)', () => {
+  describe('NFS4ERR_INVAL', () => {
+    test.todo('should return NFS4ERR_INVAL for zero-length lock');
+    test.todo('should return NFS4ERR_INVAL when offset + length overflows UINT64');
+    test.todo('should return NFS4ERR_INVAL for invalid parameters');
+  });
+
+  describe('NFS4ERR_BAD_RANGE', () => {
+    test.todo('should return NFS4ERR_BAD_RANGE on 32-bit server for offset > UINT32_MAX');
+    test.todo('should return NFS4ERR_BAD_RANGE for range overlapping UINT32_MAX boundary on 32-bit');
+    test.todo('should accept ranges up to UINT32_MAX on 32-bit servers');
+    test.todo('should accept range to UINT64_MAX (all bits 1) on any server');
+  });
+
+  describe('NFS4ERR_LOCK_RANGE', () => {
+    test.todo('should return NFS4ERR_LOCK_RANGE for sub-range lock when not supported');
+    test.todo('should return NFS4ERR_LOCK_RANGE for overlapping range from same owner when not supported');
+    test.todo('should return NFS4ERR_LOCK_RANGE from LOCKT if checking own overlapping locks');
+  });
+
+  describe('NFS4ERR_LOCK_NOTSUPP', () => {
+    test.todo('should return NFS4ERR_LOCK_NOTSUPP for atomic downgrade if not supported');
+    test.todo('should return NFS4ERR_LOCK_NOTSUPP for atomic upgrade if not supported');
+  });
+
+  describe('NFS4ERR_DENIED', () => {
+    test.todo('should return NFS4ERR_DENIED with LOCK4denied for conflicting lock');
+    test.todo('should return NFS4ERR_DENIED for upgrade blocked by other lock');
+    test.todo('should include conflicting lock details in LOCK4denied');
+  });
+
+  describe('NFS4ERR_DEADLOCK', () => {
+    test.todo('should return NFS4ERR_DEADLOCK for WRITEW_LT when deadlock detected');
+    test.todo('should return NFS4ERR_DEADLOCK for READW_LT when deadlock detected');
+    test.todo('should detect deadlock in lock upgrade scenario');
+  });
+
+  describe('NFS4ERR_BAD_STATEID', () => {
+    test.todo('should return NFS4ERR_BAD_STATEID for unknown stateid');
+    test.todo('should return NFS4ERR_BAD_STATEID for wrong filehandle');
+    test.todo('should return NFS4ERR_BAD_STATEID for wrong stateid type');
+    test.todo('should return NFS4ERR_BAD_STATEID for future seqid');
+    test.todo('should return NFS4ERR_BAD_STATEID for invalid special stateid combo');
+    test.todo('should return NFS4ERR_BAD_STATEID when new_lock_owner=true but state exists');
+  });
+
+  describe('NFS4ERR_OLD_STATEID', () => {
+    test.todo('should return NFS4ERR_OLD_STATEID for outdated stateid seqid');
+    test.todo('should accept current stateid seqid');
+  });
+
+  describe('NFS4ERR_STALE_STATEID', () => {
+    test.todo('should return NFS4ERR_STALE_STATEID after server restart');
+    test.todo('should return NFS4ERR_STALE_STATEID for revoked state');
+  });
+
+  describe('NFS4ERR_BAD_SEQID', () => {
+    test.todo('should return NFS4ERR_BAD_SEQID for incorrect lock-owner seqid');
+    test.todo('should return NFS4ERR_BAD_SEQID for incorrect open-owner seqid');
+    test.todo('should return NFS4ERR_BAD_SEQID when seqid not last + 1 or last (replay)');
+    test.todo('should prioritize NFS4ERR_BAD_SEQID over other stateid errors');
+  });
+
+  describe('NFS4ERR_STALE_CLIENTID', () => {
+    test.todo('should return NFS4ERR_STALE_CLIENTID after server restart with invalid clientid');
+    test.todo('should require SETCLIENTID after receiving NFS4ERR_STALE_CLIENTID');
+  });
+
+  describe('NFS4ERR_EXPIRED', () => {
+    test.todo('should return NFS4ERR_EXPIRED for lease-expired locks');
+    test.todo('should mark state as expired not deleted');
+  });
+
+  describe('NFS4ERR_ADMIN_REVOKED', () => {
+    test.todo('should return NFS4ERR_ADMIN_REVOKED for administratively revoked locks');
+  });
+
+  describe('NFS4ERR_LOCKED', () => {
+    test.todo('should return NFS4ERR_LOCKED for READ conflicting with mandatory lock');
+    test.todo('should return NFS4ERR_LOCKED for WRITE conflicting with mandatory lock');
+    test.todo('should return NFS4ERR_LOCKED for OPEN_DOWNGRADE with locks held');
+  });
+
+  describe('NFS4ERR_OPENMODE', () => {
+    test.todo('should return NFS4ERR_OPENMODE for WRITE with read-only stateid');
+    test.todo('should validate access mode matches operation');
+  });
+
+  describe('NFS4ERR_GRACE', () => {
+    test.todo('should return NFS4ERR_GRACE for non-reclaim LOCK during grace period');
+    test.todo('should return NFS4ERR_GRACE for READ/WRITE during grace period if conflicts possible');
+    test.todo('should allow reclaim LOCK during grace period');
+  });
+
+  describe('NFS4ERR_RESOURCE', () => {
+    test.todo('should return NFS4ERR_RESOURCE when server resources exhausted');
+  });
+
+  describe('NFS4ERR_NOFILEHANDLE', () => {
+    test.todo('should return NFS4ERR_NOFILEHANDLE when no current filehandle set');
+  });
+
+  describe('Error combinations', () => {
+    test.todo('should prioritize errors according to RFC specifications');
+    test.todo('should return most specific error for condition');
+  });
+});
+
+/**
+ * Server restart and recovery tests based on RFC 7530 Section 9.6.2
+ */
+describe('Lock reclaim after server restart (RFC 7530 §9.6.2)', () => {
+  describe('Grace period', () => {
+    test.todo('should establish grace period equal to lease period after restart');
+    test.todo('should reject non-reclaim LOCK during grace period with NFS4ERR_GRACE');
+    test.todo('should reject READ during grace period if conflicts possible');
+    test.todo('should reject WRITE during grace period if conflicts possible');
+    test.todo('should allow reclaim LOCK during grace period');
+  });
+
+  describe('Reclaim parameter usage', () => {
+    test.todo('should accept LOCK with reclaim=true during grace period');
+    test.todo('should accept LOCK with reclaim=false after grace period');
+    test.todo('should restore locks with reclaim=true');
+  });
+
+  describe('Client restart detection', () => {
+    test.todo('should detect client restart via verifier change');
+    test.todo('should break old client leases on verifier change');
+    test.todo('should release all locks for old client ID on verifier change');
+  });
+
+  describe('Server restart detection', () => {
+    test.todo('should return NFS4ERR_STALE_STATEID for stateids after restart');
+    test.todo('should return NFS4ERR_STALE_CLIENTID for client IDs after restart');
+    test.todo('should require client to establish new client ID');
+  });
+
+  describe('Lock recovery', () => {
+    test.todo('should allow clients to reclaim locks during grace period');
+    test.todo('should track reclaimed locks');
+    test.todo('should deny conflicting locks during grace period');
+  });
+
+  describe('CLAIM_PREVIOUS', () => {
+    test.todo('should accept CLAIM_PREVIOUS for opens during grace period');
+    test.todo('should not require OPEN_CONFIRM for CLAIM_PREVIOUS');
+  });
+
+  describe('Grace period end', () => {
+    test.todo('should allow normal operations after grace period');
+    test.todo('should reject late reclaim attempts after grace period');
+  });
+
+  describe('Stable storage considerations', () => {
+    test.todo('should optionally use stable storage to track granted locks');
+    test.todo('should optionally allow non-reclaim I/O if no conflicts possible');
+  });
+});