rockbed 0.1.0

package/src/lock/capability.ts

@@ -0,0 +1,89 @@
+import { lvAssert } from '../assert';
+import { Emitter, type Event } from '../event';
+
+//
+// 资源对应的是标准库中的 unsigned state 以及相关的位运算
+// 我们用两个具体的Capability结构实现（Capability命名来源于标准库）
+//
+
+/**
+ * 资源状态
+ */
+export enum CapabilityStatus {
+  Unlocked,
+  Locked,
+}
+
+/**
+ * 独享的资源
+ *
+ * acquire 获取控制权
+ * release 释放控制权
+ */
+export class Capability {
+  public onUnlocked: Event<[]>;
+
+  private readonly _onUnlocked = new Emitter<[]>();
+  private _status = CapabilityStatus.Unlocked;
+
+  constructor() {
+    this.onUnlocked = this._onUnlocked.event;
+  }
+
+  get status(): CapabilityStatus {
+    return this._status;
+  }
+
+  public acquire(): void {
+    lvAssert(this._status === CapabilityStatus.Unlocked);
+    this._status = CapabilityStatus.Locked;
+  }
+
+  public release(): void {
+    lvAssert(this._status === CapabilityStatus.Locked);
+    this._status = CapabilityStatus.Unlocked;
+    this._onUnlocked.fire();
+  }
+}
+
+/**
+ * 共享的资源
+ *
+ * acquire 获取控制权
+ * release 释放控制权
+ */
+export class SharedCapability {
+  public onUnlocked: Event<[]>;
+
+  private readonly _onUnlocked = new Emitter<[]>();
+  private _status = CapabilityStatus.Unlocked;
+  private _counter = 0;
+
+  constructor() {
+    this.onUnlocked = this._onUnlocked.event;
+  }
+
+  get status(): CapabilityStatus {
+    return this._status;
+  }
+
+  get counter(): number {
+    return this._counter;
+  }
+
+  public acquire() {
+    if (this._status === CapabilityStatus.Unlocked) {
+      this._status = CapabilityStatus.Locked;
+    }
+    this._counter++;
+  }
+
+  public release() {
+    lvAssert(this._counter > 0);
+    this._counter--;
+    if (this._counter === 0) {
+      this._status = CapabilityStatus.Unlocked;
+      this._onUnlocked.fire();
+    }
+  }
+}

package/src/lock/index.ts

@@ -0,0 +1,2 @@
+// 读写能力的互斥量，实现读写锁的能力
+export { SharedMutex } from './shared-mutex';

package/src/lock/semaphore.ts

@@ -0,0 +1,21 @@
+import type { Event } from '../event';
+import { Emitter } from '../event';
+
+/**
+ * 信号
+ *
+ * 用来模拟标准库的condition_variable
+ * 提供监听某个信号被激活的能力
+ */
+export class Semaphore {
+  public onActive: Event<[]>;
+  private readonly _onActive = new Emitter<[]>();
+
+  constructor() {
+    this.onActive = this._onActive.event;
+  }
+
+  public notify(): void {
+    this._onActive.fire();
+  }
+}

package/src/lock/shared-mutex.ts

@@ -0,0 +1,256 @@
+import { lvAssert, lvAssertNotNil } from '../assert';
+import { listenOnce } from '../event';
+import { SharedCapability, Capability, CapabilityStatus } from './capability';
+import { Semaphore } from './semaphore';
+
+/**
+ * 提供读写能力的共享互斥量
+ *
+ * 参考C++17标准库双门思想实现
+ * 接口也与标准库保持一致
+ * 方法内部禁止promise，只可以对外暴露promise
+ *
+ * 核心
+ * - 写写互斥，读写互斥，读读可重入
+ *
+ * 使用举例：
+ * class Foo {
+ *   private _mutex = new SharedMutex();
+ *
+ *   async add() {
+ *     // 上写锁
+ *     await this._mutex.lock();
+ *     // ...write something
+ *     this._mutex.unlock();
+ *   }
+ *
+ *   async getSomething1() {
+ *     // 上读锁
+ *     await this._mutex.lockShared();
+ *     try {
+ *       return xxx;
+ *     } finally {
+ *       this._mutex.unlockShared();
+ *     }
+ *   }
+ *
+ *   async getSomething2() {
+ *     // 上读锁
+ *     await this._mutex.lockShared();
+ *     try {
+ *       return xxx;
+ *     } finally {
+ *       this._mutex.unlockShared();
+ *     }
+ *   }
+ * }
+ */
+export class SharedMutex {
+  // 在第一道门外等待的写者
+  private readonly _waitingWriters: Semaphore[] = [];
+
+  // 已经通过了第一道门的写者
+  // 如果在第二道门外等待，状态为sharedLocked
+  // 如果已经进入到第二道门内拿到了锁，状态为locked
+  private _writer?: Capability;
+
+  // 在第一道门外等待的读者
+  private _waitingReader?: Semaphore;
+
+  // 拿到锁的读者
+  private _reader?: SharedCapability;
+
+  /**
+   * 是否被锁住
+   */
+  public isLocked(): boolean {
+    return Boolean(this._writer) || this._readerCount !== 0;
+  }
+
+  /**
+   * 等待并获取写锁
+   */
+  public lock(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      // 第一道门
+      if (this._writer) {
+        // 如果已经有写者进入了，其他写者等待
+        const token = new Semaphore();
+        this._waitingWriters.push(token);
+        token.onActive(() => {
+          this._writerEnterGate1(resolve);
+        });
+      } else {
+        this._writerEnterGate1(resolve);
+      }
+    });
+  }
+
+  /**
+   * 尝试获取写锁，立刻返回结果
+   */
+  public tryLock(): boolean {
+    if (this._writer || this._readerCount > 0) {
+      return false;
+    }
+    // 这里不需要await，一定可以上锁
+    this.lock();
+    return true;
+  }
+
+  /**
+   * 解除写锁
+   */
+  public unLock(): void {
+    lvAssertNotNil(this._writer);
+
+    // 打开第一道门
+    this._writer.release();
+  }
+
+  /**
+   * 解除写锁。`unLock` 的常规拼写别名。
+   */
+  public unlock(): void {
+    this.unLock();
+  }
+
+  /**
+   * 等待并获取读锁
+   */
+  public lockShared(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      // 读者只需要进第一道门
+      if (this._writer) {
+        // 如果有写者已经进入了第一道门，读者等待
+        if (!this._waitingReader) {
+          this._waitingReader = new Semaphore();
+        }
+        this._waitingReader.onActive(() => {
+          this._readerEnterGate1(resolve);
+        });
+      } else {
+        this._readerEnterGate1(resolve);
+      }
+    });
+  }
+
+  /**
+   * 尝试获取读锁，立刻返回结果
+   */
+  public tryLockShared(): boolean {
+    if (this._writer) {
+      return false;
+    }
+    // 不需要await，一定可以上锁
+    this.lockShared();
+    return true;
+  }
+
+  /**
+   * 解除读锁
+   */
+  public unLockShared(): void {
+    lvAssertNotNil(this._reader);
+    if (this._writer) {
+      // TODO(niurouwan): 暂时保留，方便验证，稳定后可以去掉
+      lvAssert(this._writer.status === CapabilityStatus.Unlocked);
+    }
+
+    this._reader.release();
+  }
+
+  /**
+   * 解除读锁。`unLockShared` 的常规拼写别名。
+   */
+  public unlockShared(): void {
+    this.unLockShared();
+  }
+
+  /**
+   * 获取当前读者数量
+   */
+  private get _readerCount(): number {
+    return this._reader ? this._reader.counter : 0;
+  }
+
+  /**
+   * 写者进入第一道门
+   */
+  private _writerEnterGate1(resolve: () => void): void {
+    lvAssert(!this._writer);
+    // 确定写者，关第一道门
+    this._writer = new Capability();
+
+    // 第二道门
+    // 等待所有读者出去
+    if (this._readerCount > 0) {
+      listenOnce(this._reader!.onUnlocked)(() => {
+        this._writerEnterGate2(resolve);
+      });
+    } else {
+      this._writerEnterGate2(resolve);
+    }
+  }
+
+  /**
+   * 写者进入第二道门
+   */
+  private _writerEnterGate2(resolve: () => void): void {
+    lvAssertNotNil(this._writer);
+    lvAssert(this._readerCount === 0);
+
+    // 成功加锁
+    this._writer.acquire();
+    listenOnce(this._writer.onUnlocked)(() => {
+      lvAssertNotNil(this._writer);
+      // 不再持有
+      this._writer = undefined;
+      this._moveForward();
+    });
+    resolve();
+  }
+
+  /**
+   * 读者进入第一道门
+   */
+  private _readerEnterGate1(resolve: () => void): void {
+    lvAssert(!this._writer);
+
+    // 门外等待的读者清除
+    this._waitingReader = undefined;
+
+    if (!this._reader) {
+      this._reader = new SharedCapability();
+      this._reader.acquire();
+      listenOnce(this._reader.onUnlocked)(() => {
+        this._moveForward();
+      });
+    } else {
+      this._reader.acquire();
+    }
+    resolve();
+  }
+
+  /**
+   * 锁释放时推进流程
+   */
+  private _moveForward(): void {
+    // 如果有写者在等待在第二道门前面，那么此时推进的一定是读锁释放，直接return即可
+    if (this._writer) {
+      return;
+    }
+
+    // 写者优先，优先通知在第一道门前面的写者
+    if (this._waitingWriters.length > 0) {
+      const semaphore = this._waitingWriters.shift()!;
+      semaphore.notify();
+      return;
+    }
+
+    // 最后通知第一道门前面的读者
+    if (this._waitingReader) {
+      this._waitingReader.notify();
+    }
+  }
+}

package/src/response/index.ts

@@ -0,0 +1 @@
+export * from './response';

package/src/response/response.ts

@@ -0,0 +1,27 @@
+export interface ISuccessResponse<T = any> {
+  code: 0;
+  data: T;
+  msg: string;
+}
+
+export interface IErrorResponse {
+  code: Exclude<number, 0>;
+  msg: string;
+}
+
+export type IResponse<T = any> = ISuccessResponse<T> | IErrorResponse;
+
+export function makeSuccessResponse<T = any>(data: T): ISuccessResponse<T> {
+  return {
+    code: 0,
+    data,
+    msg: 'success',
+  };
+}
+
+export function makeErrorResponse(code: number, msg: string) {
+  return {
+    code,
+    msg,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "isolatedModules": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}