refactor: merge 충돌 해결

Author: mintaek22

DBManager/package-lock.json

@@ -1,26 +1,22 @@
 import { Controller, Delete, Get, Query } from '@nestjs/common';
-import { KubernetesService } from './K8S/KubernetesService';
+import { K8SApiService } from './k8s/K8SApi.service';
 
 @Controller()
 export class AppController {
-  constructor(private readonly kubernetesService: KubernetesService) {}
+  constructor(private readonly k8SApiService: K8SApiService) {}
 
   @Get('/pods')
   async getAllPods() {
-    const pods = await this.kubernetesService.getAllPods();
-    return pods;
+    return await this.k8SApiService.getAllPods();
   }
 
   @Get('/create-pod')
   async createPod() {
-    const pod = await this.kubernetesService.createPod();
-    return pod;
+    return await this.k8SApiService.createPod();
   }
 
   @Delete('/delete-pod')
   async deletePod(@Query('podName') podName: string) {
-    console.log(podName);
-    const pod = await this.kubernetesService.deletePod(podName);
-    return pod;
+    return await this.k8SApiService.deletePod(podName);
   }
 }

DBManager/src/K8S/KubernetesService.ts

@@ -1,7 +1,7 @@
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
-import { KubernetesService } from './K8S/KubernetesService';
 import { ConfigModule } from '@nestjs/config';
+import { K8SApiModule } from './k8s/K8SApi.module';
 import { ScheduleModule } from '@nestjs/schedule';
 
 @Module({
@@ -10,8 +10,9 @@ import { ScheduleModule } from '@nestjs/schedule';
       isGlobal: true,
     }),
     ScheduleModule.forRoot(),
+    K8SApiModule,
   ],
   controllers: [AppController],
-  providers: [KubernetesService],
+  providers: [],
 })
 export class AppModule {}

DBManager/src/app.controller.ts

@@ -47,6 +47,10 @@ export class RedisService {
     await this.podConnection.hset(key, field, value);
   }
 
+  async delPod(key: string): Promise<void> {
+    await this.podConnection.del(key);
+  }
+
   async subscribeSession(
     channel: string,
     onMessage: (message: string) => void,

DBManager/src/app.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { K8SApiService } from './K8SApi.service';
+import { RedisModule } from 'src/config/redis/redis.module';
+
+@Module({
+  imports: [RedisModule],
+  exports: [K8SApiService],
+  providers: [K8SApiService],
+})
+export class K8SApiModule {}

DBManager/src/config/redis/redis.service.ts

@@ -0,0 +1,107 @@
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { RedisService } from 'src/config/redis/redis.service';
+import { CoreV1Api, KubeConfig, Watch } from '@kubernetes/client-node';
+
+@Injectable()
+export class K8SApiService implements OnModuleInit {
+  private k8sApi: CoreV1Api;
+  private k8sWatch: Watch;
+  private namespace = 'default';
+
+  constructor(private readonly redisService: RedisService) {}
+
+  async onModuleInit() {
+    const kc = new KubeConfig();
+    kc.loadFromDefault();
+    this.k8sApi = kc.makeApiClient(CoreV1Api);
+    this.k8sWatch = new Watch(kc);
+    this.startWatchPod();
+  }
+
+  async getPodIp(podName: string): Promise<string> {
+    const podInfo = await this.k8sApi.readNamespacedPod(
+      podName,
+      this.namespace,
+    );
+    return podInfo.body.status.podIP || 'Pending';
+  }
+
+  startWatchPod() {
+    const path = `/api/v1/namespaces/${this.namespace}/pods`;
+    const queryParams = {
+      allowWatchBookmarks: true,
+      labelSelector: 'app=mysql',
+    };
+    const handlePodEvent = async (type: string, apiObj: any, watchObj: any) => {
+      const podName = watchObj.object.metadata.name;
+      const podStatus = watchObj.object.status;
+      const curPodIp = await this.redisService.hgetPod(podName, 'podIp');
+
+      if (type === 'ADDED') {
+        await this.redisService.hsetPod(podName, 'activeUser', 0);
+        await this.redisService.hsetPod(
+          podName,
+          'podIp',
+          podStatus.podIp || '',
+        );
+      } else if (type === 'MODIFIED' && podStatus.podIP && curPodIp == '') {
+        const podIp = podStatus.podIP;
+        await this.redisService.hsetPod(podName, 'podIp', podIp);
+      } else if (type === 'DELETED') {
+        await this.redisService.delPod(podName);
+      }
+    };
+
+    this.k8sWatch.watch(path, queryParams, handlePodEvent, (err) => {
+      console.error(err);
+    });
+  }
+
+  async createPod() {
+    const mysqlPod = {
+      metadata: {
+        generateName: 'mysql-',
+        labels: {
+          app: 'mysql',
+        },
+      },
+      spec: {
+        containers: [
+          {
+            name: 'mysql',
+            image: 'mysql',
+          },
+        ],
+      },
+    };
+
+    return await this.k8sApi.createNamespacedPod(this.namespace, mysqlPod);
+  }
+
+  async deletePod(podName: string) {
+    return await this.k8sApi.deleteNamespacedPod(podName, this.namespace);
+  }
+
+  async getAllPods() {
+    const podList = await this.k8sApi.listNamespacedPod(this.namespace);
+    const podResult = {};
+
+    for (const pod of podList.body.items) {
+      const podName = pod.metadata.name;
+      console.log(podName);
+
+      const podInfo = await this.k8sApi.readNamespacedPod(
+        podName,
+        this.namespace,
+      );
+      const podIp = podInfo.body.status.podIP;
+      console.log(podIp);
+
+      podResult[podName] = podIp;
+    }
+    return {
+      podCnt: Object.keys(podResult).length,
+      podResult,
+    };
+  }
+}