@lifeready/core 1.0.0 → 1.0.1

package/src/lib/api/lock.gql.ts

@@ -0,0 +1,67 @@
+import { JWK } from 'node-jose';
+import { gqlTyped } from '../_common/ast';
+import { DateTime, LockState, UUID } from './types';
+
+export interface LockFragmentResult {
+  created: DateTime;
+  modified: DateTime;
+  version?: UUID;
+  expiryTime: DateTime;
+  state: LockState;
+}
+export const LockFragment = gqlTyped<LockFragmentResult>`
+fragment LockFragment on LockField {
+  created
+  modified
+  version
+  expiryTime
+  state
+}`;
+
+export interface UpdateLockMutationResult {
+  updateLock: {
+    lock: LockFragmentResult;
+  };
+}
+export const UpdateLockMutation = gqlTyped<UpdateLockMutationResult>`
+mutation UpdateLockMutation($input: UpdateLockInput!) {
+  updateLock(input: $input) {
+    lock {
+      ...LockFragment
+    }
+  }
+}
+${LockFragment}
+`;
+
+export interface AcquireLockMutationResult {
+  acquireLock: {
+    lock: LockFragmentResult;
+  };
+}
+export const AcquireLockMutation = gqlTyped<AcquireLockMutationResult>`
+mutation AcquireLockMutation($input: AcquireLockInput!) {
+  acquireLock(input: $input) {
+    lock {
+      ...LockFragment
+    }
+  }
+}
+${LockFragment}
+`;
+
+export interface ReleaseLockMutationResult {
+  releaseLock: {
+    lock: LockFragmentResult;
+  };
+}
+export const ReleaseLockMutation = gqlTyped<ReleaseLockMutationResult>`
+mutation ReleaseLockMutation($input: ReleaseLockInput!) {
+  releaseLock(input: $input) {
+    lock {
+      ...LockFragment
+    }
+  }
+}
+${LockFragment}
+`;

package/src/lib/api/lock.service.spec.ts

@@ -0,0 +1,549 @@
+import { TestBed } from '@angular/core/testing';
+import {
+  delaySec,
+  lrConfigureTestingModule,
+  lrExpectAsyncThrow,
+  lrExpectGqlErrorCodes,
+  lrExpectGqlErrorCodesSync,
+  lrit,
+} from '../_common/tests';
+import {
+  loginTestUser,
+  logoutUser,
+} from '../auth/life-ready-auth.service.spec';
+import { environment } from 'projects/lr-auth-app/src/environments/environment';
+import { deleteAllRootDirectories, getDirectory } from './item2.service.spec';
+import { LockService } from './lock.service';
+import { LrGraphQLService, LrMutation } from './lr-graphql';
+import { Item2Service } from './item2.service';
+import { gqlTyped } from '../_common/ast';
+import { setupTps2 } from '../trusted-parties/trusted-party2.service.spec';
+import { TrustedParty2Service } from '../trusted-parties/trusted-party2.service';
+import { AccessRoleChoice, DirectoryNode, LockState } from './types';
+import { LockFragment, LockFragmentResult } from './lock.gql';
+import {
+  LrApiErrorCode,
+  LrErrorCode,
+  LrLockedException,
+} from '../_common/exceptions';
+
+const TIMEOUT = 1000 * 60 * 10;
+
+interface DebugMutation {
+  debugMutation: {
+    name: string;
+  };
+}
+const DebugMutation = gqlTyped<DebugMutation>`
+mutation DebugMutation($input: DebugMutationInput!) {
+  debugMutation(input: $input) {
+    name
+  }
+}`;
+
+interface LockQueryResult {
+  lock: LockFragmentResult;
+}
+const LockQuery = gqlTyped<LockQueryResult>`
+query LockQuery($resourceId: String!) {
+  lock(resourceId: $resourceId) {
+    ...LockFragment
+  }
+}
+${LockFragment}
+`;
+
+interface GetDirectoryAndLockQueryResult {
+  lock: LockFragmentResult;
+  directory: DirectoryNode;
+}
+const GetDirectoryAndLockQuery = gqlTyped<GetDirectoryAndLockQueryResult>`
+query GetDirectoryAndLockQuery($resourceId: String!, $directoryId: LrRelayIdInput!) {
+  lock(resourceId: $resourceId) {
+    ...LockFragment
+  }
+  directory(id: $directoryId) {
+    created
+    modified
+    plainMeta
+  }
+}
+${LockFragment}
+`;
+
+interface GetDirectoryQueryResult {
+  lock: LockFragmentResult;
+  directory: DirectoryNode;
+}
+const GetDirectoryQuery = gqlTyped<GetDirectoryQueryResult>`
+query GetDirectoryQuery($directoryId: LrRelayIdInput!) {
+  directory(id: $directoryId) {
+    created
+    modified
+    plainMeta
+  }
+}
+`;
+
+function debugMutation(name: string) {
+  return new LrMutation({
+    mutation: DebugMutation,
+    variables: {
+      input: {
+        name,
+      },
+    },
+  });
+}
+
+describe('LockService', () => {
+  let lockService: LockService;
+  let lrGraphQL: LrGraphQLService;
+  let item2: Item2Service;
+  let tp2Service: TrustedParty2Service;
+
+  beforeEach(async () => {
+    lrConfigureTestingModule();
+    lockService = TestBed.inject(LockService);
+    lrGraphQL = TestBed.inject(LrGraphQLService);
+    item2 = TestBed.inject(Item2Service);
+    tp2Service = TestBed.inject(TrustedParty2Service);
+  }, TIMEOUT);
+
+  // You would always query the lock together with other fields. There's no point
+  // in getting the lock by itself. So this is only useful in testing.
+  async function getLock(resourceId: string) {
+    const res = await lrGraphQL.query({
+      query: LockQuery,
+      variables: {
+        resourceId,
+      },
+    });
+
+    if (res.lock && res.lock.state !== LockState.UNLOCKED) {
+      throw new LrLockedException(`Resource lock state: ${res.lock.state}`);
+    }
+
+    return res.lock?.version;
+  }
+
+  async function updateLock(resourceId: string, version: string) {
+    return (
+      await lrGraphQL.lrMutate(
+        lockService.updateLockMutation(resourceId, version)
+      )
+    ).updateLock.lock.version;
+  }
+
+  async function releaseLock(resourceId: string, version: string) {
+    return (
+      await lrGraphQL.lrMutate(
+        lockService.releaseLockMutation(resourceId, version)
+      )
+    ).releaseLock.lock.version;
+  }
+
+  async function acquireLock(resourceId: string, timeoutMs: number) {
+    return (
+      await lrGraphQL.lrMutate(
+        lockService.acquireLockMutation(resourceId, timeoutMs)
+      )
+    ).acquireLock.lock.version;
+  }
+
+  async function createDirectory(
+    name: string,
+    options: {
+      parents?: {
+        id: string;
+        keyId?: string;
+      }[];
+      asRoot?: boolean;
+    }
+  ) {
+    return (
+      await lrGraphQL.lrMutate(
+        item2.createDirectory({
+          plainMetaJson: { name },
+          cipherMetaClearJson: { name },
+          asRootDirectory: options.asRoot,
+          parentDirectories: options.parents?.map((parent) => ({
+            directoryId: parent.id,
+            wrappingKeyId: parent.keyId,
+          })),
+        })
+      )
+    ).createDirectory.directory;
+  }
+
+  lrit(
+    'should lock',
+    async () => {
+      const {
+        username: username1,
+        password: password1,
+      } = environment.test.users[0];
+      const {
+        username: username2,
+        password: password2,
+      } = environment.test.users[1];
+
+      const { U1_TP_U2_ID, U2_TP_U1_ID } = await setupTps2(
+        username1,
+        password1,
+        username2,
+        password2
+      );
+
+      // ----------------------------------------------------------
+      // User 1
+      // ----------------------------------------------------------
+      await loginTestUser(username1, password1);
+      await deleteAllRootDirectories();
+
+      const D1 = await createDirectory('D1试用', { asRoot: true });
+      const D2 = await createDirectory('D2', { asRoot: true });
+
+      await lrGraphQL.lrMutate(
+        tp2Service.shareDirectory({
+          tpId: U1_TP_U2_ID,
+          itemId: D2.id,
+          accessRole: AccessRoleChoice.READER, // only READ permission is required
+        })
+      );
+
+      const version1 = await getLock(D2.id);
+      expect(version1).toBeUndefined(
+        'New directory should not have a lock entity.'
+      );
+
+      // ----------------------------------------------------------
+      // Logout
+      // ----------------------------------------------------------
+      await logoutUser();
+
+      (await lrExpectAsyncThrow(getLock(D1.id))).toBeTruthy();
+
+      // ----------------------------------------------------------
+      // User 2
+      // ----------------------------------------------------------
+      await loginTestUser(username2, password2);
+
+      // D1 not shared with user 2
+      (await lrExpectGqlErrorCodes(getLock(D1.id))).toContain(
+        LrApiErrorCode.WRONG_PERMISSIONS
+      );
+      (await lrExpectGqlErrorCodes(acquireLock(D1.id, 1000 * 5))).toContain(
+        LrApiErrorCode.WRONG_PERMISSIONS
+      );
+
+      const d = await getDirectory(D2.id);
+
+      // D2 is shared with user 2
+      const version1a = await getLock(D2.id);
+      expect(version1a).toEqual(version1);
+
+      const update = lockService.updateLockMutation(D2.id, version1);
+
+      await lrGraphQL.lrMutate([update, debugMutation('version2')]);
+
+      const version2 = (await update.promise).updateLock.lock.version;
+      expect(version2).not.toEqual(version1);
+
+      (
+        await lrExpectGqlErrorCodes(
+          lrGraphQL.lrMutate([
+            lockService.updateLockMutation(D2.id, version1),
+            debugMutation('version2-fail'),
+          ])
+        )
+      ).toContain(
+        LrApiErrorCode.VERSION_MISMATCH,
+        'Should fail to update using the same version'
+      );
+
+      (await lrExpectGqlErrorCodes(acquireLock(D2.id, 1000 * 1000))).toContain(
+        'BAD_ARGUMENT',
+        'Should not be able set lock expiry with large value,'
+      );
+
+      const version3 = await acquireLock(D2.id, 1000 * 3);
+
+      (await lrExpectGqlErrorCodes(acquireLock(D2.id, 1000 * 3))).toContain(
+        LrApiErrorCode.LOCKED,
+        'Should not be able to acquireLock() when already locked'
+      );
+
+      (await lrExpectGqlErrorCodes(getLock(D2.id))).toContain(
+        LrErrorCode.Locked,
+        'Should not be able to getLock() when already locked'
+      );
+
+      (await lrExpectGqlErrorCodes(updateLock(D2.id, version3))).toContain(
+        LrApiErrorCode.LOCKED,
+        'Should not be able to updateVersion() while locked'
+      );
+
+      (await lrExpectGqlErrorCodes(releaseLock(D2.id, version2))).toContain(
+        LrApiErrorCode.VERSION_MISMATCH,
+        'Should not be able to releaseLock() using wrong version'
+      );
+
+      // Release now
+      await releaseLock(D2.id, version3);
+
+      const version4 = await getLock(D2.id);
+      expect(version4).not.toEqual(version3);
+
+      (await lrExpectGqlErrorCodes(releaseLock(D2.id, version4))).toContain(
+        LrApiErrorCode.EXPIRED,
+        'Should not be able to releaseLock() when lock has expired'
+      );
+
+      await updateLock(D2.id, version4);
+      const version5 = await getLock(D2.id);
+      expect(version5).not.toEqual(version4);
+
+      // ----------------------------
+      // This time let lock expire
+      // ----------------------------
+      const version6 = await acquireLock(D2.id, 1000 * 2);
+      expect(version6).not.toEqual(version5);
+
+      await delaySec(2.5);
+
+      const version6a = await getLock(D2.id);
+      expect(version6a).toEqual(
+        version6,
+        'Version should not have changed when lock expires'
+      );
+
+      const version7 = await acquireLock(D2.id, 100);
+      expect(version7).not.toEqual(version6);
+
+      await delaySec(1);
+
+      const version8 = await updateLock(D2.id, version7);
+    },
+    TIMEOUT
+  );
+
+  async function testMissingUpdates({
+    optimistic,
+    mutex,
+  }: {
+    optimistic: boolean;
+    mutex: boolean;
+  }) {
+    const D1 = await createDirectory('D1试用', { asRoot: true });
+    await item2.updateDirectoryExec({
+      directoryId: D1.id,
+      plainMetaJson: { count: 0 },
+    });
+
+    let total = 0;
+    let contentions = 0;
+    let optimisticLocks = 0;
+    let mutexLocks = 0;
+
+    /**
+     *
+     * @param acquire True to use acquireLock(), False to use updateLock()
+     */
+    const createTask = async (acquire: boolean) => {
+      while (1) {
+        try {
+          await delaySec(Math.random() * 0.5);
+
+          let version;
+          let dir;
+
+          // Read the directory
+          if (acquire) {
+            // Lock using the mutex lock
+            version = await acquireLock(D1.id, 5000);
+            dir = await lrGraphQL.query({
+              query: GetDirectoryQuery,
+              variables: {
+                directoryId: D1.id,
+              },
+            });
+          } else {
+            // Lock using the optimistic lock
+            dir = await lrGraphQL.query({
+              query: GetDirectoryAndLockQuery,
+              variables: {
+                resourceId: D1.id,
+                directoryId: D1.id,
+              },
+            });
+
+            if (dir.lock && dir.lock.state !== LockState.UNLOCKED) {
+              throw new LrLockedException(
+                `Resource lock state: ${dir.lock.state}`
+              );
+            }
+          }
+
+          await delaySec(Math.random() * 0.2);
+
+          // Update the directory
+          const updateDirectoryMutation = item2.updateDirectoryMutation({
+            directoryId: D1.id,
+            plainMetaJson: { count: dir.directory.plainMetaJson.count + 1 },
+          });
+
+          let lockMutation;
+          if (acquire) {
+            // Using mutex lock
+            lockMutation = lockService.releaseLockMutation(D1.id, version);
+          } else {
+            // Using optimistic lock
+            lockMutation = lockService.updateLockMutation(
+              D1.id,
+              dir.lock?.version
+            );
+          }
+
+          await lrGraphQL.lrMutate([updateDirectoryMutation, lockMutation]);
+
+          if (acquire) {
+            ++mutexLocks;
+          } else {
+            ++optimisticLocks;
+          }
+
+          total++;
+          console.log('before version:', dir.lock?.version);
+          console.log('before count:', dir.directory.plainMetaJson.count);
+          break;
+        } catch (error) {
+          console.log('error: ', error);
+          contentions++;
+        }
+      }
+    };
+
+    const tasks = [];
+    const TASK_COUNT = 10;
+    for (let i = 0; i < TASK_COUNT; ++i) {
+      let acquire;
+
+      if (optimistic && mutex) {
+        acquire = Math.random() > 0.5;
+      } else if (optimistic) {
+        acquire = false;
+      } else if (mutex) {
+        acquire = true;
+      } else {
+        throw new Error('Must at least specify one of optimistic or mutex');
+      }
+
+      tasks.push(createTask(acquire));
+    }
+
+    await Promise.all(tasks);
+
+    // Get the directory
+    const res = await lrGraphQL.query({
+      query: GetDirectoryAndLockQuery,
+      variables: {
+        resourceId: D1.id,
+        directoryId: D1.id,
+      },
+    });
+
+    console.log('Total count: ', total);
+    console.log('Contentions: ', contentions);
+    console.log('Optimistic locks: ', optimisticLocks);
+    console.log('Mutex locks: ', mutexLocks);
+
+    expect(res.directory.plainMetaJson.count).toEqual(total);
+    expect(res.directory.plainMetaJson.count).toEqual(TASK_COUNT);
+    expect(contentions).toBeGreaterThan(0);
+  }
+
+  lrit(
+    'should not have missing updates using optimistic lock',
+    async () => {
+      const {
+        username: username1,
+        password: password1,
+      } = environment.test.users[0];
+
+      // ----------------------------------------------------------
+      // User 1
+      // ----------------------------------------------------------
+      await loginTestUser(username1, password1);
+
+      await testMissingUpdates({
+        optimistic: true,
+        mutex: false,
+      });
+    },
+    TIMEOUT
+  );
+
+  lrit(
+    'should not have missing updates using mutex lock',
+    async () => {
+      const {
+        username: username1,
+        password: password1,
+      } = environment.test.users[0];
+
+      // ----------------------------------------------------------
+      // User 1
+      // ----------------------------------------------------------
+      await loginTestUser(username1, password1);
+
+      await testMissingUpdates({
+        optimistic: false,
+        mutex: true,
+      });
+    },
+    TIMEOUT
+  );
+
+  lrit(
+    'should not have missing updates using mutex lock',
+    async () => {
+      const {
+        username: username1,
+        password: password1,
+      } = environment.test.users[0];
+
+      // ----------------------------------------------------------
+      // User 1
+      // ----------------------------------------------------------
+      await loginTestUser(username1, password1);
+
+      await testMissingUpdates({
+        optimistic: false,
+        mutex: true,
+      });
+    },
+    TIMEOUT
+  );
+
+  lrit(
+    'should not have missing updates using both optimistic and mutex lock',
+    async () => {
+      const {
+        username: username1,
+        password: password1,
+      } = environment.test.users[0];
+
+      // ----------------------------------------------------------
+      // User 1
+      // ----------------------------------------------------------
+      await loginTestUser(username1, password1);
+
+      await testMissingUpdates({
+        optimistic: true,
+        mutex: true,
+      });
+    },
+    TIMEOUT
+  );
+});

package/src/lib/api/lock.service.ts

@@ -0,0 +1,57 @@
+import { Injectable, Injector, NgZone } from '@angular/core';
+import { LrMutation, LrService } from './lr-graphql';
+import {
+  AcquireLockMutation,
+  ReleaseLockMutation,
+  UpdateLockMutation,
+} from './lock.gql';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+
+@RunOutsideAngular({
+  ngZoneName: 'ngZone',
+})
+@Injectable({
+  providedIn: 'root',
+})
+export class LockService extends LrService {
+  constructor(private ngZone: NgZone, private injector: Injector) {
+    super(injector);
+  }
+
+  // Updating the lock version is always to be down along with another mutation.
+  updateLockMutation(resourceId: string, version: string) {
+    return new LrMutation({
+      mutation: UpdateLockMutation,
+      variables: {
+        input: {
+          resourceId,
+          version,
+        },
+      },
+    });
+  }
+
+  acquireLockMutation(resourceId: string, timeoutMs: number) {
+    return new LrMutation({
+      mutation: AcquireLockMutation,
+      variables: {
+        input: {
+          resourceId,
+          timeoutMs,
+        },
+      },
+    });
+  }
+
+  releaseLockMutation(resourceId: string, version: string) {
+    return new LrMutation({
+      mutation: ReleaseLockMutation,
+      variables: {
+        input: {
+          resourceId,
+          version,
+        },
+      },
+    });
+  }
+}

package/src/lib/api/lr-apollo.service.spec.ts

@@ -0,0 +1,27 @@
+import { TestBed } from '@angular/core/testing';
+import { Apollo } from 'apollo-angular';
+import { KeyGraphService } from '../../public-api';
+import { LrApolloService } from './lr-apollo.service';
+
+const keyGraph = jasmine.createSpyObj<KeyGraphService>('KeyGraphService', [
+  'addKeys',
+]);
+const apollo = jasmine.createSpyObj<Apollo>('Apollo', ['query', 'mutate']);
+
+describe('LrApolloService', () => {
+  let service: LrApolloService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        { provide: Apollo, useValue: apollo },
+        { provide: KeyGraphService, useValue: keyGraph },
+      ],
+    });
+    service = TestBed.inject(LrApolloService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});