feat(lock): Implement the Lock API on HTTP (#478)

* WIP on Lock API

Signed-off-by: Xavier Geerinck <[email protected]>

* Add lock API

Signed-off-by: Xavier Geerinck <[email protected]>

* Remove unused variable

Signed-off-by: Xavier Geerinck <[email protected]>

* working on conflicts

Signed-off-by: Xavier Geerinck <[email protected]>

* Resolve issue

Signed-off-by: Xavier Geerinck <[email protected]>

* This should not have been committed

Signed-off-by: Xavier Geerinck <[email protected]>

---------

Signed-off-by: Xavier Geerinck <[email protected]>

Author: XavierGeerinck

daprdocs/content/en/js-sdk-docs/js-client/_index.md

@@ -471,8 +471,8 @@ async function start() {
   let expiryInSeconds = 1000;
 
   console.log(`Acquiring lock on ${storeName}, ${resourceId} as owner: ${lockOwner}`);
-  const tryLockResponse = await client.lock.tryLock(storeName, resourceId, lockOwner, expiryInSeconds);
-  console.log(tryLockResponse);
+  const lockResponse = await client.lock.lock(storeName, resourceId, lockOwner, expiryInSeconds);
+  console.log(lockResponse);
 
   console.log(`Unlocking on ${storeName}, ${resourceId} as owner: ${lockOwner}`);
   const unlockResponse = await client.lock.unlock(storeName, resourceId, lockOwner);

examples/distributedLock/README.md

@@ -4,7 +4,7 @@ This example demonstrates 2 features (Try Lock & Unlock) from the [Distributed l
 
 It demonstrates the **Distributed Lock** API's following methods:
 
-- `TryLock`
+- `Lock`
 - `Unlock`
 
 > **Note:** Make sure to use the latest proto bindings by running scripts/fetch-proto.sh file.
@@ -17,12 +17,12 @@ It demonstrates the **Distributed Lock** API's following methods:
 
 ## Overview
 
-The TryLock and Unlock calls are implemented under the client.lock attribute.
+The Lock and Unlock calls are implemented under the client.lock attribute.
 
-#### TryLock Example
+#### Lock Example
 
 ```typescript
-const tryLockResponse = await client.lock.tryLock(storeName, resourceId, lockOwner, expiryInSeconds);
+const lockResponse = await client.lock.lock(storeName, resourceId, lockOwner, expiryInSeconds);
 ```
 
 #### Unlock Example
@@ -33,14 +33,14 @@ const unlockResponse = await client.lock.unlock(storeName, resourceId, lockOwner
 
 ### Start the Lock application.
 
-Execute the example under the folder `examples/distributedLock/TryLockApplication`
+Execute the example under the folder `examples/distributedLock/LockApplication`
 
 ```bash
-cd examples/distributedLock/TryLockApplication
+cd examples/distributedLock/LockApplication
 npm install
 ```
 
-To run the `TryLock`, execute the following command:
+To run the `Lock`, execute the following command:
 
 ```bash
 dapr run --app-id lock --app-protocol grpc --components-path ./components npm run start
@@ -61,7 +61,7 @@ You should see the following output from the application:
 
 ### Start the Unlock Example.
 
-Run `UnlockApplication` after `TryLockApplication` is ran.
+Run `UnlockApplication` after `LockApplication` is ran.
 
 Navigate to examples/distributedLock/UnlockApplication.
 

examples/distributedLock/TryLockApplication/src/index.ts

@@ -30,8 +30,8 @@ async function start() {
   let expiryInSeconds = 1000;
 
   console.log(`Acquiring lock on ${storeName}, ${resourceId} as owner: ${lockOwner}`);
-  const tryLockResponse = await client.lock.tryLock(storeName, resourceId, lockOwner, expiryInSeconds);
-  console.log(tryLockResponse);
+  const lockResponse = await client.lock.lock(storeName, resourceId, lockOwner, expiryInSeconds);
+  console.log(lockResponse);
 
   console.log(`Unlocking on ${storeName}, ${resourceId} as owner: ${lockOwner}`);
   const unlockResponse = await client.lock.unlock(storeName, resourceId, lockOwner);
@@ -44,8 +44,8 @@ async function start() {
 
   expiryInSeconds = 25;
   console.log(`Acquiring lock on ${storeName}, ${resourceId} as owner: ${lockOwner}`);
-  const tryLockResponse1 = await client.lock.tryLock(storeName, resourceId, lockOwner, expiryInSeconds);
-  console.log("Acquired Lock? " + tryLockResponse1.success);
+  const lockResponse1 = await client.lock.lock(storeName, resourceId, lockOwner, expiryInSeconds);
+  console.log("Acquired Lock? " + lockResponse1.success);
 
   await new Promise((resolve) => setTimeout(resolve, 20000));
 }

examples/distributedLock/UnLockApplication/src/index.ts

@@ -29,10 +29,10 @@ async function start() {
   const lockOwner = "owner2";
   const expiryInSeconds = 25;
 
-  // Trying to acquire the lock which is being used by the other process(TryLockApplication)
+  // Trying to acquire the lock which is being used by the other process(LockApplication)
   console.log(`Acquiring lock on ${storeName}, ${resourceId} as owner: ${lockOwner}`);
-  let tryLockResponse = await client.lock.tryLock(storeName, resourceId, lockOwner, expiryInSeconds);
-  console.log("Acquired Lock? " + tryLockResponse.success);
+  let lockResponse = await client.lock.lock(storeName, resourceId, lockOwner, expiryInSeconds);
+  console.log("Acquired Lock? " + lockResponse.success);
   console.log("Lock cannot be acquired as it belongs to the other process");
 
   console.log(`Unlocking on ${storeName}, ${resourceId} as owner: ${lockOwner}`);
@@ -45,8 +45,8 @@ async function start() {
 
   // Trying to acquire the lock after the other process lock is expired
   console.log(`Acquiring lock on ${storeName}, ${resourceId} as owner: ${lockOwner}`);
-  tryLockResponse = await client.lock.tryLock(storeName, resourceId, lockOwner, expiryInSeconds);
-  console.log("Acquired lock after the lock from the other process expired? " + tryLockResponse.success);
+  lockResponse = await client.lock.lock(storeName, resourceId, lockOwner, expiryInSeconds);
+  console.log("Acquired lock after the lock from the other process expired? " + lockResponse.success);
 
   console.log(`Unlocking on ${storeName}, ${resourceId} as owner: ${lockOwner}`);
   unLockResponse = await client.lock.unlock(storeName, resourceId, lockOwner);

src/implementation/Client/GRPCClient/lock.ts

@@ -12,7 +12,7 @@ limitations under the License.
 */
 
 import GRPCClient from "./GRPCClient";
-import { TryLockResponse as TryLockResponseResult } from "../../../types/lock/TryLockResponse";
+import { LockResponse as LockResponseResult } from "../../../types/lock/LockResponse";
 import { UnlockResponse as UnLockResponseResult, LockStatus } from "../../../types/lock/UnlockResponse";
 import {
   TryLockRequest,
@@ -29,12 +29,12 @@ export default class GRPCClientLock implements IClientLock {
     this.client = client;
   }
 
-  async tryLock(
+  async lock(
     storeName: string,
     resourceId: string,
     lockOwner: string,
     expiryInSeconds: number,
-  ): Promise<TryLockResponseResult> {
+  ): Promise<LockResponseResult> {
     const request = new TryLockRequest()
       .setStoreName(storeName)
       .setResourceId(resourceId)
@@ -48,7 +48,7 @@ export default class GRPCClientLock implements IClientLock {
           return reject(err);
         }
 
-        const wrapped: TryLockResponseResult = {
+        const wrapped: LockResponseResult = {
           success: res.getSuccess(),
         };
 

src/implementation/Client/HTTPClient/lock.ts

@@ -12,25 +12,62 @@ limitations under the License.
 */
 
 import HTTPClient from "./HTTPClient";
-import { TryLockResponse as TryLockResponseResult } from "../../../types/lock/TryLockResponse";
-import { UnlockResponse as UnLockResponseResult } from "../../../types/lock/UnlockResponse";
+import { LockResponse } from "../../../types/lock/LockResponse";
+import { UnlockResponse, LockStatus } from "../../../types/lock/UnlockResponse";
 import IClientLock from "../../../interfaces/Client/IClientLock";
+import { KeyValueType } from "../../../types/KeyValue.type";
 
 export default class HTTPClientLock implements IClientLock {
   client: HTTPClient;
 
   constructor(client: HTTPClient) {
     this.client = client;
   }
-  tryLock(
-    _storeName: string,
-    _resourceId: string,
-    _lockOwner: string,
-    _expiryInSeconds: number,
-  ): Promise<TryLockResponseResult> {
-    throw new Error("HTTP is currently not supported.");
+
+  async lock(storeName: string, resourceId: string, lockOwner: string, expiryInSeconds: number): Promise<LockResponse> {
+    const data = {
+      resourceId,
+      lockOwner,
+      expiryInSeconds,
+    };
+
+    const result = await this.client.executeWithApiVersion("v1.0-alpha1", `/lock/${storeName}`, {
+      method: "POST",
+      body: data,
+    });
+
+    return {
+      success: (result as KeyValueType)["success"],
+    };
+  }
+
+  async unlock(storeName: string, resourceId: string, lockOwner: string): Promise<UnlockResponse> {
+    const data = {
+      resourceId,
+      lockOwner,
+    };
+
+    const result = await this.client.executeWithApiVersion("v1.0-alpha1", `/unlock/${storeName}`, {
+      method: "POST",
+      body: data,
+    });
+
+    return {
+      status: this._statusToLockStatus((result as KeyValueType)["status"]),
+    };
   }
-  unlock(_storeName: string, _resourceId: string, _lockOwner: string): Promise<UnLockResponseResult> {
-    throw new Error("HTTP is currently not supported.");
+
+  _statusToLockStatus(status: number): LockStatus {
+    switch (status) {
+      case 0:
+        return LockStatus.Success;
+      case 1:
+        return LockStatus.LockDoesNotExist;
+      case 2:
+        return LockStatus.LockBelongsToOthers;
+      case 3:
+      default:
+        return LockStatus.InternalError;
+    }
   }
 }

src/interfaces/Client/IClientLock.ts

@@ -11,7 +11,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { TryLockResponse } from "../../types/lock/TryLockResponse";
+import { LockResponse } from "../../types/lock/LockResponse";
 import { UnlockResponse } from "../../types/lock/UnlockResponse";
 
 export default interface IClientLock {
@@ -22,7 +22,7 @@ export default interface IClientLock {
    * @param lockOwner owner owning the lock.
    * @param expiryInSeconds the expiry time for the lock.
    */
-  tryLock(storeName: string, resourceId: string, lockOwner: string, expiryInSeconds: number): Promise<TryLockResponse>;
+  lock(storeName: string, resourceId: string, lockOwner: string, expiryInSeconds: number): Promise<LockResponse>;
 
   /**
    *

src/types/lock/TryLockResponse.ts renamed to src/types/lock/LockResponse.ts

@@ -11,6 +11,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-export type TryLockResponse = {
+export type LockResponse = {
   success: boolean;
 };

test/components/common/lock-redis.yaml

@@ -0,0 +1,12 @@
+apiVersion: dapr.io/v1alpha1
+kind: Component
+metadata:
+  name: redislock
+spec:
+  type: lock.redis
+  version: v1
+  metadata:
+  - name: redisHost
+    value: localhost:6379
+  - name: redisPassword
+    value: ""

test/e2e/common/client.test.ts

@@ -11,15 +11,16 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { randomUUID } from "crypto";
 import {
   CommunicationProtocolEnum,
   DaprClient,
   LogLevel,
   StateConcurrencyEnum,
   StateConsistencyEnum,
 } from "../../../src";
-import { describe, expect, it } from "@jest/globals";
 import { sleep } from "../../../src/utils/NodeJS.util";
+import { LockStatus } from "../../../src/types/lock/UnlockResponse";
 
 const daprHost = "127.0.0.1";
 const daprGrpcPort = "50000";
@@ -150,6 +151,74 @@ describe("common/client", () => {
     });
   });
 
+  describe("distributed lock", () => {
+    runIt("should be able to acquire a new lock and unlock", async (client: DaprClient) => {
+      const resourceId = randomUUID();
+      const lock = await client.lock.lock("redislock", resourceId, "owner1", 1000);
+      expect(lock.success).toEqual(true);
+      const unlock = await client.lock.unlock("redislock", resourceId, "owner1");
+      expect(unlock.status).toEqual(LockStatus.Success);
+    });
+
+    runIt("should be not be able to unlock when the lock is not acquired", async (client: DaprClient) => {
+      const resourceId = randomUUID();
+      const unlock = await client.lock.unlock("redislock", resourceId, "owner1");
+      expect(unlock.status).toEqual(LockStatus.LockDoesNotExist);
+    });
+
+    runIt("should be able to acquire a lock after the previous lock is expired", async (client: DaprClient) => {
+      const resourceId = randomUUID();
+      let lock = await client.lock.lock("redislock", resourceId, "owner1", 5);
+      expect(lock.success).toEqual(true);
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      lock = await client.lock.lock("redislock", resourceId, "owner2", 5);
+      expect(lock.success).toEqual(false);
+    });
+
+    runIt(
+      "should not be able to acquire a lock when the same lock is acquired by another owner",
+      async (client: DaprClient) => {
+        const resourceId = randomUUID();
+        const lockOne = await client.lock.lock("redislock", resourceId, "owner1", 5);
+        expect(lockOne.success).toEqual(true);
+        const lockTwo = await client.lock.lock("redislock", resourceId, "owner2", 5);
+        expect(lockTwo.success).toEqual(false);
+      },
+    );
+
+    runIt(
+      "should be able to acquire a lock when a different lock is acquired by another owner",
+      async (client: DaprClient) => {
+        const lockOne = await client.lock.lock("redislock", randomUUID(), "owner1", 5);
+        expect(lockOne.success).toEqual(true);
+        const lockTwo = await client.lock.lock("redislock", randomUUID(), "owner2", 5);
+        expect(lockTwo.success).toEqual(true);
+      },
+    );
+
+    runIt(
+      "should not be able to acquire a lock when that lock is acquired by another owner/process",
+      async (client: DaprClient) => {
+        const resourceId = randomUUID();
+        const lockOne = await client.lock.lock("redislock", resourceId, "owner3", 5);
+        expect(lockOne.success).toEqual(true);
+        const lockTwo = await client.lock.lock("redislock", resourceId, "owner4", 5);
+        expect(lockTwo.success).toEqual(false);
+      },
+    );
+
+    runIt(
+      "should not be able to unlock a lock when that lock is acquired by another owner/process",
+      async (client: DaprClient) => {
+        const resourceId = randomUUID();
+        const lockOne = await client.lock.lock("redislock", resourceId, "owner5", 5);
+        expect(lockOne.success).toEqual(true);
+        const unlock = await client.lock.unlock("redislock", resourceId, "owner6");
+        expect(unlock.status).toEqual(LockStatus.LockBelongsToOthers);
+      },
+    );
+  });
+
   describe("state", () => {
     const stateStoreName = "state-redis";
     const stateStoreMongoDbName = "state-mongodb";