Merge pull request #136 from boostcampwm-2022/dev

Deploy: 3주차 결과

Author: wcho21

@wabinar-crdt/convergence.test.ts

@@ -0,0 +1,83 @@
+import CRDT from './index';
+import LinkedList, { RemoteInsertOperation } from './linked-list';
+import { Node } from './node';
+
+/**
+ * utilities
+ * 바로 전달하면 같은 인스턴스를 가리키게 되어 remote operation 의미가 사라짐
+ */
+const deepCopyRemoteInsertion = (op: RemoteInsertOperation) => {
+  const { prevId, node } = op;
+
+  const copy = { ...node };
+  Object.setPrototypeOf(copy, Node.prototype);
+
+  return { prevId, node: copy as Node };
+};
+
+const remoteInsertThroughSocket = (crdt: CRDT, op: RemoteInsertOperation) => {
+  const copy = deepCopyRemoteInsertion(op);
+  crdt.remoteInsert(copy);
+};
+
+/**
+ * 모든 remote site 문자열이 일치하는지 확인
+ */
+const convergenceCheck = () => {
+  expect(원희.read()).toEqual(주영.read());
+  expect(주영.read()).toEqual(도훈.read());
+  expect(도훈.read()).toEqual(세영.read());
+};
+
+/**
+ * 테스트용 site들
+ */
+const 원희 = new CRDT(1, 1, new LinkedList());
+const 주영 = new CRDT(1, 2, new LinkedList());
+const 도훈 = new CRDT(1, 3, new LinkedList());
+const 세영 = new CRDT(1, 4, new LinkedList());
+
+describe('Convergence', () => {
+  it('하나의 site에서 삽입', () => {
+    const 원희remotes = [
+      원희.localInsert(-1, '녕'),
+      원희.localInsert(-1, '안'),
+    ];
+
+    [주영, 도훈, 세영].forEach((나) => {
+      원희remotes.forEach((op) => remoteInsertThroughSocket(나, op));
+    });
+
+    convergenceCheck();
+  });
+
+  it('여러 site에서 같은 위치에 삽입', () => {
+    const 도훈remote = 도훈.localInsert(0, '왭');
+    const 세영remote = 세영.localInsert(0, '?');
+
+    remoteInsertThroughSocket(도훈, 세영remote);
+    remoteInsertThroughSocket(세영, 도훈remote);
+
+    [원희, 주영].forEach((나) => {
+      remoteInsertThroughSocket(나, 도훈remote);
+      remoteInsertThroughSocket(나, 세영remote);
+    });
+
+    convergenceCheck();
+  });
+
+  it('여러 site에서 다른 위치에 삽입', () => {
+    const 원희remote = 원희.localInsert(0, '네');
+    const 주영remote = 주영.localInsert(1, '!');
+
+    remoteInsertThroughSocket(원희, 주영remote);
+    remoteInsertThroughSocket(주영, 원희remote);
+
+    [도훈, 세영].forEach((나) => {
+      remoteInsertThroughSocket(나, 원희remote);
+      remoteInsertThroughSocket(나, 주영remote);
+    });
+
+    convergenceCheck();
+  });
+});

@wabinar-crdt/crdt.test.ts

@@ -0,0 +1,34 @@
+import CRDT from './index';
+import LinkedList from './linked-list';
+
+describe('Local operation', () => {
+  const initialStructure = new LinkedList();
+
+  const 나 = new CRDT(1, 1, initialStructure);
+
+  it('head에 삽입', () => {
+    let innerText = 나.read();
+
+    나.localInsert(-1, '녕');
+    expect(나.read()).toEqual('녕' + innerText);
+
+    innerText = 나.read();
+
+    나.localInsert(-1, '안');
+    expect(나.read()).toEqual('안' + innerText);
+  });
+
+  it('tail에 삽입', () => {
+    let innerText = 나.read();
+
+    나.localInsert(1, '하');
+    expect(나.read()).toEqual(innerText + '하');
+  });
+
+  it('head 삭제', () => {
+    let innerText = 나.read();
+
+    나.localDelete(0);
+    expect(나.read()).toEqual(innerText.replace('안', ''));
+  });
+});

@wabinar-crdt/index.ts

@@ -0,0 +1,67 @@
+import LinkedList, {
+  RemoteDeleteOperation,
+  RemoteInsertOperation,
+} from './linked-list';
+import { Identifier } from './node';
+
+class CRDT {
+  private clock: number;
+  private client: number;
+  private structure: LinkedList;
+
+  constructor(
+    initialclock: number = 1,
+    client: number = 0,
+    initialStructure: LinkedList,
+  ) {
+    this.clock = initialclock;
+    this.client = client;
+
+    Object.setPrototypeOf(initialStructure, LinkedList.prototype);
+    this.structure = initialStructure as LinkedList;
+  }
+
+  get data() {
+    return this.structure;
+  }
+
+  localInsert(index: number, letter: string): RemoteInsertOperation {
+    const id = new Identifier(this.clock++, this.client);
+
+    const remoteInsertion = this.structure.insertByIndex(index, letter, id);
+
+    return remoteInsertion;
+  }
+
+  localDelete(index: number): RemoteDeleteOperation {
+    const targetId = this.structure.deleteByIndex(index);
+
+    return { targetId, clock: this.clock };
+  }
+
+  remoteInsert({ prevId, node }: RemoteInsertOperation) {
+    const prevIndex = this.structure.insertById(prevId, node);
+
+    if (++this.clock < node.id.clock) {
+      this.clock = node.id.clock + 1;
+    }
+
+    return prevIndex;
+  }
+
+  remoteDelete({ targetId, clock }: RemoteDeleteOperation) {
+    const targetIndex = this.structure.deleteById(targetId);
+
+    if (++this.clock < clock) {
+      this.clock = clock + 1;
+    }
+
+    return targetIndex;
+  }
+
+  read() {
+    return this.structure.stringify();
+  }
+}
+
+export default CRDT;

@wabinar-crdt/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest', // to use typescript
+  verbose: true,
+  modulePathIgnorePatterns: ['<rootDir>/dist/'],
+};

@wabinar-crdt/linked-list.ts

@@ -0,0 +1,189 @@
+import { Identifier, Node } from './node';
+
+type RemoteIdentifier = Identifier | null;
+
+type ModifiedIndex = number | null;
+
+export interface RemoteInsertOperation {
+  prevId: Identifier | null;
+  node: Node;
+}
+
+export interface RemoteDeleteOperation {
+  targetId: Identifier | null;
+  clock: number;
+}
+
+export default class LinkedList {
+  head?: Node;
+
+  insertByIndex(
+    index: number,
+    letter: string,
+    id: Identifier,
+  ): RemoteInsertOperation {
+    const node = new Node(letter, id);
+
+    try {
+      // insertion to head
+      if (!this.head || index === -1) {
+        node.next = this.head;
+        node.prev = null;
+
+        this.head = node;
+
+        return { prevId: null, node };
+      }
+
+      const prevNode = this.findByIndex(index);
+
+      node.next = prevNode.next;
+      prevNode.next = node;
+
+      const { id: prevId } = prevNode;
+
+      node.prev = prevId;
+
+      return { prevId, node };
+    } catch (e) {
+      throw new Error(`insertByIndex 실패 ^^\n${e}`);
+    }
+  }
+
+  deleteByIndex(index: number): RemoteIdentifier {
+    try {
+      // head deleted
+      if (index === 0) {
+        if (!this.head) throw new Error('head가 없는데 어떻게 삭제하셨나요 ^^');
+
+        if (!this.head.next) {
+          this.head = undefined;
+          return null;
+        }
+
+        this.head.next.prev = null;
+        this.head = this.head.next;
+
+        return null;
+      }
+
+      const prevNode = this.findByIndex(index - 1);
+
+      const targetNode = prevNode.next;
+
+      prevNode.next = targetNode?.next;
+
+      if (!targetNode || !targetNode.id) return null;
+
+      return targetNode.id;
+    } catch (e) {
+      throw new Error(`deleteByIndex 실패 ^^\n${e}`);
+    }
+  }
+
+  insertById(id: RemoteIdentifier, node: Node): ModifiedIndex {
+    try {
+      let prevNode, prevIndex;
+
+      // insertion to head
+      if (id === null) {
+        // 기존 head가 없거나 현재 node가 선행하는 경우
+        if (!this.head || node.precedes(this.head)) {
+          node.next = this.head;
+          this.head = node;
+
+          return null;
+        }
+
+        prevNode = this.head;
+        prevIndex = 0;
+      } else {
+        let { node: targetNode, index: targetIndex } = this.findById(id);
+
+        prevNode = targetNode;
+        prevIndex = targetIndex;
+      }
+
+      // prevNode에 연결된 노드가 현재 node에 선행하는 경우
+      while (prevNode.next && prevNode.next.precedes(node)) {
+        prevNode = prevNode.next;
+        prevIndex++;
+      }
+
+      node.next = prevNode.next;
+      node.prev = prevNode.id;
+      prevNode.next = node;
+
+      return prevIndex + 1;
+    } catch (e) {
+      console.log(`insertById 실패 ^^\n${e}`);
+
+      return null;
+    }
+  }
+
+  deleteById(id: RemoteIdentifier): ModifiedIndex {
+    try {
+      if (!id) {
+        if (!this.head) throw new Error('일어날 수 없는 일이 발생했어요 ^^');
+
+        this.head = this.head.next;
+
+        return null;
+      }
+
+      const { node: targetNode, index: targetIndex } = this.findById(id);
+      const prevNode = this.findByIndex(targetIndex - 1);
+
+      prevNode.next = targetNode.next;
+
+      return targetIndex;
+    } catch (e) {
+      console.log(`deleteById 실패 ^^\n${e}`);
+
+      return null;
+    }
+  }
+
+  stringify(): string {
+    let node: Node | undefined = this.head;
+    let result = '';
+
+    while (node) {
+      result += node.value;
+      node = node.next;
+    }
+
+    return result;
+  }
+
+  private findByIndex(index: number): Node {
+    let count = 0;
+    let currentNode: Node | undefined = this.head;
+
+    while (count < index && currentNode) {
+      currentNode = currentNode.next;
+      count++;
+    }
+
+    if (!currentNode) throw new Error('없는 인덱스인데요 ^^');
+
+    return currentNode;
+  }
+
+  private findById(id: Identifier) {
+    let count = 0;
+    let currentNode: Node | undefined = this.head;
+
+    while (currentNode) {
+      if (JSON.stringify(currentNode.id) === JSON.stringify(id)) {
+        return { node: currentNode, index: count };
+      }
+
+      currentNode = currentNode.next;
+      count++;
+    }
+
+    throw new Error('없는 노드인데요 ^^');
+  }
+}