3장 완료

Author: easdkr

example03/src/application/port/input/router-network.input-port.ts

@@ -8,22 +8,23 @@ import { RouterId } from 'src/domain/vo/router.id';
 export class RouterNetworkInputPort implements RouterNetworkUseCase {
   public constructor(private readonly _routerNetworkOutputPort: RouterNetworkOutputPort) {}
 
-  async addNetworkToRouter(routerId: RouterId, network: Network): Promise<Router> {
-    const router = await this.fetchRouter(routerId);
-    return await this.createNetwork(router, network);
+  addNetworkToRouter(routerId: RouterId, network: Network): Router {
+    const router = this.fetchRouter(routerId);
+
+    return this.createNetwork(router, network);
   }
 
-  private async fetchRouter(routerId: RouterId): Promise<Router> {
-    return await this._routerNetworkOutputPort.fetchRouterById(routerId);
+  private fetchRouter(routerId: RouterId): Router {
+    return this._routerNetworkOutputPort.fetchRouterById(routerId);
   }
 
-  private async createNetwork(router: Router, network: Network): Promise<Router> {
+  private createNetwork(router: Router, network: Network): Router {
     const newRouter = NetworkOperation.createNewNetwork(router, network);
 
-    return (await this.persistNetwork(router)) ? newRouter : router;
+    return this.persistNetwork(router) ? newRouter : router;
   }
 
-  private async persistNetwork(router: Router): Promise<boolean> {
-    return await this._routerNetworkOutputPort.persistRouter(router);
+  private persistNetwork(router: Router): boolean {
+    return this._routerNetworkOutputPort.persistRouter(router);
   }
 }

example03/src/application/port/output/router-network.output-port.ts

@@ -2,6 +2,6 @@ import { Router } from 'src/domain/entity/router';
 import { RouterId } from 'src/domain/vo/router.id';
 
 export interface RouterNetworkOutputPort {
-  fetchRouterById(routerId: RouterId): Promise<Router>;
-  persistRouter(router: Router): Promise<boolean>;
+  fetchRouterById(routerId: RouterId): Router;
+  persistRouter(router: Router): boolean;
 }

example03/src/application/usecase/router-network.usecase.ts

@@ -16,5 +16,5 @@ export interface RouterNetworkUseCase {
    * - And CIDR이 유효하다
    * - Then 라우터에 네트워크를 추가한다
    */
-  addNetworkToRouter(routerId: RouterId, network: Network): Promise<Router>;
+  addNetworkToRouter(routerId: RouterId, network: Network): Router;
 }

example03/src/domain/entity/router.ts

@@ -6,8 +6,7 @@ import { RouterType } from 'src/domain/vo/router.type';
 import { Predicate } from 'src/utils/types';
 
 export class Router {
-  private _networkSwitch: Switch;
-  public constructor(private readonly _routerType: RouterType, private readonly _routerId: RouterId) {}
+  public constructor(private readonly _routerType: RouterType, private readonly _routerId: RouterId, private _networkSwitch?: Switch) {}
 
   public static filterRouterByType(routerType: RouterType): Predicate<Router> {
     return routerType === RouterType.CORE ? this.isCore : this.isEdge;
@@ -28,15 +27,21 @@ export class Router {
   public retrieveNetworks(): Network[] {
     return this._networkSwitch.getNetworks();
   }
+
   public getRouterType(): RouterType {
     return this._routerType;
   }
 
+  public getRouterId(): RouterId {
+    return this._routerId;
+  }
+
   public toString(): string {
     return `
       Router { 
         type: ${RouterType[this._routerType]}, 
         id: ${this._routerId.toString()}
+        networkSwitch: ${this._networkSwitch.toString()}
       }
     `;
   }

example03/src/domain/entity/switch.ts

@@ -1,5 +1,6 @@
 import { IP } from 'src/domain/vo/ip';
 import { Network } from 'src/domain/vo/network';
+import { Protocol } from 'src/domain/vo/protocol';
 import { SwitchId } from 'src/domain/vo/switch.id';
 import { SwitchType } from 'src/domain/vo/switch.type';
 
@@ -15,4 +16,15 @@ export class Switch {
     const copied = [...this._networks];
     return copied;
   }
+
+  public toString(): string {
+    return `
+            Switch {
+              type: ${SwitchType[this._type]}
+              id: ${this._id.toString()}
+              address: ${this._address.address}(${Protocol[this._address.protocol]})
+              network: ${this._networks.toString()}
+            }
+      `;
+  }
 }

example03/src/domain/service/network.operation.ts

@@ -9,19 +9,19 @@ import { Network } from 'src/domain/vo/network';
  * 새로운 네트워크 객체를 생성하고 해당 객체를 라우터에 연결된 스위치에 추가
  */
 export class NetworkOperation {
-  public static createNewNetwork(router: Router, { address, name, cidr }: Network): Router {
-    const availabilitySpec = new NetworkAvailabilitySpecification(address, name, cidr);
+  public static createNewNetwork(router: Router, network: Network): Router {
+    const availabilitySpec = new NetworkAvailabilitySpecification(network.address, network.name, network.cidr);
     const cidrSpec = new CIDRSpecification();
     const routerTypeSpec = new RouterTypeSpecification();
     const amountSpec = new NetworkAmountSpecification();
 
-    if (!cidrSpec.isSatisfiedBy(cidr)) throw new Error(`CIDR is below ${CIDRSpecification.MINIMUM_ALLOWED_CIRD}`);
+    if (!cidrSpec.isSatisfiedBy(network.cidr)) throw new Error(`CIDR is below ${CIDRSpecification.MINIMUM_ALLOWED_CIRD}`);
 
     if (!availabilitySpec.isSatisfiedBy(router)) throw new Error('Address already exist');
 
-    if (amountSpec.and(routerTypeSpec).isSatisfiedBy(router)) {
-      const network = router.createNetwork(address, name, cidr);
-      router.addNetworkToSwitch(network);
+    if (amountSpec.isSatisfiedBy(router) && routerTypeSpec.isSatisfiedBy(router)) {
+      const _network = router.createNetwork(network.address, network.name, network.cidr);
+      router.addNetworkToSwitch(_network);
     }
 
     return router;

example03/src/domain/specification/cidr.specification.ts

@@ -4,6 +4,6 @@ export class CIDRSpecification extends AbstractSpecification<number> {
   public static readonly MINIMUM_ALLOWED_CIRD = 8;
 
   isSatisfiedBy(cidr: number): boolean {
-    return Number.isInteger(cidr) && cidr > CIDRSpecification.MINIMUM_ALLOWED_CIRD;
+    return Number.isInteger(cidr) && cidr >= CIDRSpecification.MINIMUM_ALLOWED_CIRD;
   }
 }

example03/src/domain/vo/network.ts

@@ -1,4 +1,5 @@
 import { IP } from 'src/domain/vo/ip';
+import { Protocol } from 'src/domain/vo/protocol';
 
 export class Network {
   public constructor(private readonly _address: IP, private readonly _name: string, private readonly _cidr: number) {
@@ -15,6 +16,16 @@ export class Network {
   }
 
   get cidr(): number {
-    return this.cidr;
+    return this._cidr;
+  }
+
+  public toString(): string {
+    return `
+                  Network {
+                    address: ${this._address.address}(${Protocol[this._address.protocol]}),
+                    name: ${this._name},
+                    cird: ${this._cidr}
+                  }
+    `;
   }
 }

example03/src/domain/vo/router.id.ts

@@ -11,6 +11,10 @@ export class RouterId {
     return new RouterId(UUID.randomUUID());
   }
 
+  public getId(): UUID {
+    return this._id;
+  }
+
   toString(): string {
     return this._id.toString();
   }

example03/src/domain/vo/switch.type.ts

@@ -1 +1,4 @@
-export enum SwitchType {}
+export enum SwitchType {
+  LAYER2,
+  LAYER3,
+}

example03/src/framework/adapter/input/router-network.cli.adapter.ts

@@ -0,0 +1,22 @@
+import { RouterNetworkInputPort } from 'src/application/port/input/router-network.input-port';
+import { RouterNetworkUseCase } from 'src/application/usecase/router-network.usecase';
+import { Router } from 'src/domain/entity/router';
+import { Network } from 'src/domain/vo/network';
+import { RouterId } from 'src/domain/vo/router.id';
+import { routerNetworkFileAdapter } from 'src/framework/adapter/output/router-network.file.adapter';
+
+export class RouterNetworkCLIAdapter {
+  private _routerNetworkUsecase: RouterNetworkUseCase;
+
+  constructor() {
+    this.setAdapters();
+  }
+
+  public addNetwork(routerId: RouterId, network: Network): Router {
+    return this._routerNetworkUsecase.addNetworkToRouter(routerId, network);
+  }
+
+  private setAdapters(): void {
+    this._routerNetworkUsecase = new RouterNetworkInputPort(routerNetworkFileAdapter);
+  }
+}

example03/src/framework/adapter/output/router-network.file.adapter.ts

@@ -0,0 +1,46 @@
+import { RouterNetworkOutputPort } from 'src/application/port/output/router-network.output-port';
+import { Router } from 'src/domain/entity/router';
+import { Switch } from 'src/domain/entity/switch';
+import { IP } from 'src/domain/vo/ip';
+import { Network } from 'src/domain/vo/network';
+import { RouterId } from 'src/domain/vo/router.id';
+import { RouterType } from 'src/domain/vo/router.type';
+import { SwitchId } from 'src/domain/vo/switch.id';
+import { SwitchType } from 'src/domain/vo/switch.type';
+
+class RouterNetworkFileAdapter implements RouterNetworkOutputPort {
+  private _routers: Router[];
+
+  constructor() {
+    this._routers = [];
+    this.createSampleRouter();
+  }
+
+  private createSampleRouter(): void {
+    const routerId = RouterId.withId('ca23800e-9b5a-11eb-a8b3-0242ac130003');
+    const network = new Network(new IP('10.0.0.0'), 'HR', 8);
+    const networkSwitch = new Switch(SwitchType.LAYER3, SwitchId.withoutId(), [network], new IP('9.0.0.9'));
+    const router = new Router(RouterType.EDGE, routerId, networkSwitch);
+    this._routers.push(router);
+  }
+
+  public fetchRouterById(routerId: RouterId): Router {
+    let retrievedRouter: Router;
+
+    for (const router of this._routers) {
+      if (router.getRouterId().getId().equals(routerId.getId())) {
+        retrievedRouter = router;
+        break;
+      }
+    }
+
+    return retrievedRouter;
+  }
+
+  public persistRouter(router: Router): boolean {
+    return !!this._routers.push(router);
+  }
+}
+
+// for singlton
+export const routerNetworkFileAdapter = new RouterNetworkFileAdapter();

example03/src/main.ts

@@ -1,8 +1,10 @@
-import { RouterType } from 'src/domain/vo/router.type';
-import { RouterViewCliAdapter } from 'src/framework/adapter/input/router-view.cli.adapter';
+import { IP } from 'src/domain/vo/ip';
+import { Network } from 'src/domain/vo/network';
+import { RouterId } from 'src/domain/vo/router.id';
+import { RouterNetworkCLIAdapter } from 'src/framework/adapter/input/router-network.cli.adapter';
 
-const cli = new RouterViewCliAdapter();
-// const routers = await cli.obtainRelatedRouters(RouterType.EDGE);
-// console.log(routers);
-
-cli.obtainRelatedRouters(RouterType.EDGE).then((v) => console.log(v.toString()));
+const cli = new RouterNetworkCLIAdapter();
+const routerId = RouterId.withId('ca23800e-9b5a-11eb-a8b3-0242ac130003');
+const network = new Network(new IP('20.0.0.0'), 'Marketing', 8);
+const router = cli.addNetwork(routerId, network);
+console.log(router.toString());

example03/src/utils/specification/abstract.specification.ts

@@ -1,4 +1,3 @@
-import { AndSpecification } from 'src/utils/specification/and.specification';
 import { Specification } from 'src/utils/specification/specification';
 
 export abstract class AbstractSpecification<T> implements Specification<T> {
@@ -8,3 +7,14 @@ export abstract class AbstractSpecification<T> implements Specification<T> {
     return new AndSpecification<T>(this, specification);
   }
 }
+
+// 다른 파일에 생성시 순환 참조 문제가 발생하여 한 파일에 선언
+export class AndSpecification<T> extends AbstractSpecification<T> {
+  constructor(private readonly _spec1: Specification<T>, private readonly _spec2: Specification<T>) {
+    super();
+  }
+
+  public isSatisfiedBy(t: T): boolean {
+    return this._spec1.isSatisfiedBy(t) && this._spec2.isSatisfiedBy(t);
+  }
+}

example03/src/utils/specification/and.specification.ts

@@ -17,4 +17,8 @@ export class UUID {
   public toString(): string {
     return this._uuid;
   }
+
+  public equals(target: UUID): boolean {
+    return this._uuid === target._uuid;
+  }
 }