private int lockSequenceIndex;
    private byte[] fileId;
    private final Smb2Lock[] locks;

    /**
     * Constructs an SMB2 lock request with the specified parameters.
     *
     * @param config the configuration for this request
     * @param fileId the file identifier for the file to lock
     * @param locks the array of lock elements to apply
     */

            bufferIndex += this.unlocks[i].decode(buffer, bufferIndex, buffer.length);
        }

        for (int i = 0; i < this.locks.length; i++) {
            this.locks[i] = createLockRange();
            bufferIndex += this.locks[i].decode(buffer, bufferIndex, buffer.length);
        }

        return start - bufferIndex;
    }

    /**
     * @return
     */

            // Verify total bytes written (structure + lock data)
            assertEquals(24 + 24, bytesWritten); // 24 for structure, 24 for lock
        }

        @Test
        @DisplayName("Should write request structure correctly with multiple locks")
        void testWriteBytesWireFormatMultipleLocks() {
            Smb2Lock[] locks = new Smb2Lock[] { new Smb2Lock(0L, 100L, Smb2Lock.SMB2_LOCKFLAG_EXCLUSIVE_LOCK),

	rng := rand.New(rand.NewSource(0))
	quorum := 0
	// Numbers of unique locks
	for _, locks := range []int{100, 1000, 1e6} {
		if testing.Short() && locks > 100 {
			continue
		}
		t.Run(fmt.Sprintf("%d-locks", locks), func(t *testing.T) {
			// Number of readers per lock...
			for _, readers := range []int{1, 10, 100} {
				if locks > 1000 && readers > 1 {
					continue
				}

This directory is intended to contain Redisson [1] JARs for Maven Resolver Named Locks using Redisson.

See here [2] on how to add necessary JARs.

[1] https://github.com/redisson/redisson

		dst.Code = dsync.RespErr
		dst.Err = err.Error()
	}
	return dst, nil
}

const (
	// Lock maintenance interval.
	lockMaintenanceInterval = 1 * time.Minute

	// Lock validity duration
	lockValidityDuration = 1 * time.Minute
)

// lockMaintenance loops over all locks and discards locks
// that have not been refreshed for some time.
func lockMaintenance(ctx context.Context) {

        setField(cmd, "timeout", 3000L);
        // arrays of one lock and one unlock range
        LockingAndXRange lock = new LockingAndXRange(false);
        lock.encode(new byte[20], 0); // initialise fields by encoding to set pid etc (though not needed)
        setField(lock, "pid", 123);
        setField(lock, "byteOffset", 100L);
        setField(lock, "lengthInBytes", 200L);
        LockingAndXRange unlock = new LockingAndXRange(false);

This directory is intended to contain Hazelcast [1] JARs for Maven Resolver Named Locks using Hazelcast.

See here [2] on how to add necessary JARs.

[1] https://github.com/hazelcast/hazelcast

	processVirtualMemoryMaxBytes    = "virtual_memory_max_bytes"
)

var (
	processLocksReadTotalMD           = NewGaugeMD(processLocksReadTotal, "Number of current READ locks on this peer")
	processLocksWriteTotalMD          = NewGaugeMD(processLocksWriteTotal, "Number of current WRITE locks on this peer")
	processCPUTotalSecondsMD          = NewCounterMD(processCPUTotalSeconds, "Total user and system CPU time spent in seconds")

	Source          string // Contains line, function and filename requesting the lock.
	Group           bool   // indicates if it was a group lock.
	Owner           string // Owner represents the UUID of the owner who originally requested the lock.
	Quorum          int    // Quorum represents the quorum required for this lock to be active.
	idx             int    `msg:"-"` // index of the lock in the lockMap.
}