Method acquire

src/server/cache/distributedLock.ts:78–177

* Acquire a distributed lock * @param lockName - Name of the lock * @param options - Override default options for this specific lock * @returns Promise

(
    lockName: string,
    options?: Partial<DistributedLockOptions>
  )

   * @returns Promise<LockResult>
   */
  async acquire(
    lockName: string,
    options?: Partial<DistributedLockOptions>
  ): Promise<LockResult> {
    const opts = { ...this.options, ...options };
    const cacheManager = await getCacheManager();
    const lockKey = `${opts.prefix}:${lockName}`;
    const lockId = nanoid();
    const lockValue = {
      id: lockId,
      acquiredAt: Date.now(),
      acquiredBy: process.pid.toString(), // Use process ID as identifier
    };

    let retries = 0;
    const maxRetries = opts.skipOnFailure ? 1 : opts.maxRetries;

    while (retries < maxRetries) {
      try {
        // Try to acquire the lock
        const existingLock = await cacheManager.get(lockKey);

        if (!existingLock) {
          // Lock is available, try to acquire it
          await cacheManager.set(
            lockKey,
            JSON.stringify(lockValue),
            opts.timeout
          );

          await sleep(Math.random() * 100); // NOTICE: avoid setting too quickly to conflict

          // Verify we actually got the lock (handle race conditions)
          const verifyLock = await cacheManager.get(lockKey);
          if (verifyLock) {
            const parsedLock = JSON.parse(String(verifyLock));
            if (parsedLock.id === lockId) {
              logger.debug(
                `[DistributedLock] Successfully acquired lock: ${lockName}`
              );

              return {
                acquired: true,
                lockId,
                release: async () => {
                  await this.release(lockName, lockId);
                },
              };
            }
          }
        } else {
          // Check if the existing lock has expired
          const parsedLock = JSON.parse(String(existingLock));
          const lockAge = Date.now() - parsedLock.acquiredAt;

          if (lockAge > opts.timeout) {
            // Lock has expired, try to clean it up and retry
            logger.warn(