Merge pull request #58 from easy-cloud-Knet/refactor/infra_separation

Refactor/infra separation

Author: ukleon123

api/create_vm.go

@@ -5,16 +5,75 @@ import (
 	"errors"
 	"net/http"
 
-	"github.com/easy-cloud-Knet/KWS_Control/client/model"
 	"github.com/easy-cloud-Knet/KWS_Control/service"
+	"github.com/easy-cloud-Knet/KWS_Control/structure"
 	"github.com/easy-cloud-Knet/KWS_Control/util"
 )
 
+// ApiCreateVmRequest for POST /vm HTTP Request Body contract.
+type ApiCreateVmRequest struct {
+	DomType    string          `json:"domType"`
+	DomName    string          `json:"domName"`
+	UUID       structure.UUID  `json:"uuid"`
+	OS         string          `json:"os"`
+	HWInfo     ApiHardwareInfo `json:"HWInfo"`
+	Network    ApiNetworkInfo  `json:"network"`
+	Users      []ApiUserInfo   `json:"users"`
+	SubnetType string          `json:"Subnettype"`
+}
+
+type ApiHardwareInfo struct {
+	CPU    uint32 `json:"cpu"`
+	Memory uint32 `json:"memory"` // MiB
+	Disk   uint32 `json:"disk"`   // MiB
+}
+
+type ApiNetworkInfo struct {
+	IPs []string `json:"ips"`
+	// NetType은 내부에서 0 고정 — API 클라이언트가 전송하더라도 무시됨
+}
+
+type ApiUserInfo struct {
+	Name              string   `json:"name"`
+	Groups            string   `json:"groups"`
+	Password          string   `json:"passWord"`
+	SSHAuthorizedKeys []string `json:"ssh"`
+}
+
+// ToServiceInput은 HTTP DTO를 서비스 계층 DTO로 변환
+func (r *ApiCreateVmRequest) ToServiceInput() service.CreateVMInput {
+	users := make([]service.UserSpec, len(r.Users))
+	for i, u := range r.Users {
+		users[i] = service.UserSpec{
+			Name:              u.Name,
+			Groups:            u.Groups,
+			Password:          u.Password,
+			SSHAuthorizedKeys: u.SSHAuthorizedKeys,
+		}
+	}
+	return service.CreateVMInput{
+		UUID:    r.UUID,
+		DomType: r.DomType,
+		DomName: r.DomName,
+		OS:      r.OS,
+		HardwareInfo: service.HardwareSpec{
+			CPU:    r.HWInfo.CPU,
+			Memory: r.HWInfo.Memory,
+			Disk:   r.HWInfo.Disk,
+		},
+		Network: service.NetworkSpec{
+			IPs: r.Network.IPs,
+		},
+		Users:      users,
+		SubnetType: r.SubnetType,
+	}
+}
+
 func (c *handlerContext) createVm(w http.ResponseWriter, r *http.Request) {
 	log := util.GetLogger()
 	defer r.Body.Close()
 
-	var req model.CreateVMRequest
+	var req ApiCreateVmRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		log.Error("createVm: failed to parse request body: %v", err, true)
 		var syntaxErr *json.SyntaxError
@@ -26,13 +85,12 @@ func (c *handlerContext) createVm(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if req.HardwareInfo.Memory == 0 || req.HardwareInfo.CPU == 0 || req.HardwareInfo.Disk == 0 {
+	if req.HWInfo.Memory == 0 || req.HWInfo.CPU == 0 || req.HWInfo.Disk == 0 {
 		util.RespondError(w, http.StatusBadRequest, "Memory, CPU, and Disk must be non-zero")
 		return
 	}
 
-	err := service.CreateVM(req, c.context, c.rdb)
-	if err != nil {
+	if err := service.CreateVM(req.ToServiceInput(), c.context, c.rdb); err != nil {
 		log.Error("createVm: failed to create VM: %v", err, true)
 		util.RespondError(w, http.StatusInternalServerError, err.Error())
 		return

api/get_vm_status.go

@@ -14,6 +14,26 @@ type ApiVmStatusRequest struct {
 	Type string         `json:"type"` // "cpu", "memory", or "disk"
 }
 
+type ApiVmCpuStatusResponse struct {
+	System float64 `json:"system_time"`
+	Idle   float64 `json:"idle_time"`
+	Usage  float64 `json:"usage_percent"`
+}
+
+type ApiVmMemoryStatusResponse struct {
+	Total       uint64  `json:"total_gb"`
+	Used        uint64  `json:"used_gb"`
+	Available   uint64  `json:"available_gb"`
+	UsedPercent float64 `json:"used_percent"`
+}
+
+type ApiVmDiskStatusResponse struct {
+	Total       uint64  `json:"total_gb"`
+	Used        uint64  `json:"used_gb"`
+	Free        uint64  `json:"free_gb"`
+	UsedPercent float64 `json:"used_percent"`
+}
+
 func (c *handlerContext) vmStatus(w http.ResponseWriter, r *http.Request) {
 	log := util.GetLogger()
 	defer r.Body.Close()
@@ -36,11 +56,14 @@ func (c *handlerContext) vmStatus(w http.ResponseWriter, r *http.Request) {
 
 	switch statusType {
 	case "cpu":
-		data, err = service.GetVMCpuInfo(req.UUID, c.context)
+		cpu, e := service.GetVMCpuInfo(req.UUID, c.context)
+		data, err = ApiVmCpuStatusResponse{System: cpu.System, Idle: cpu.Idle, Usage: cpu.Usage}, e
 	case "memory":
-		data, err = service.GetVMMemoryInfo(req.UUID, c.context)
+		mem, e := service.GetVMMemoryInfo(req.UUID, c.context)
+		data, err = ApiVmMemoryStatusResponse{Total: mem.Total, Used: mem.Used, Available: mem.Available, UsedPercent: mem.UsedPercent}, e
 	case "disk":
-		data, err = service.GetVMDiskInfo(req.UUID, c.context)
+		disk, e := service.GetVMDiskInfo(req.UUID, c.context)
+		data, err = ApiVmDiskStatusResponse{Total: disk.Total, Used: disk.Used, Free: disk.Free, UsedPercent: disk.UsedPercent}, e
 	}
 
 	if err != nil {

client/cms.go

@@ -11,54 +11,102 @@ import (
 	"github.com/easy-cloud-Knet/KWS_Control/util"
 )
 
+// CmsClient는 CMS서비스에 서브넷/인스턴스 생성을 요청하는 HTTP 클라이언트.
 type CmsClient struct {
 	baseURL string
 	client  *http.Client
 }
 
-type NewSubnetRequest struct {
-	IP      string `json:"ip"`
+type CmsNewInstanceResponse struct {
+	IP      string `json:"IP"`
 	MacAddr string `json:"macAddr"`
 	SdnUUID string `json:"sdnUUID"`
 }
 
-type subnetRequest struct {
+type CmsDeleteInstanceResponse struct {
+	Detail string `json:"detail,omitempty"`
+}
+
+type cmsNewInstanceRequestBody struct {
 	Subnet string `json:"Subnet"`
 }
 
+type cmsDeleteInstanceRequestBody struct {
+	IP string `json:"IP"`
+}
+
 func NewCmsClient() *CmsClient {
-	CMS_HOST := os.Getenv("CMS_HOST")
-	if CMS_HOST == "" {
+	host := os.Getenv("CMS_HOST")
+	if host == "" {
 		log := util.GetLogger()
 		log.Error("CMS_HOST Re:Check your env variable", true)
-		CMS_HOST = "localhost:8080"
-		log.Warn("CMS_HOST set: %s", CMS_HOST, true)
+		host = "localhost:8080"
+		log.Warn("CMS_HOST set: %s", host, true)
 	}
 	return &CmsClient{
-		baseURL: CMS_HOST,
+		baseURL: host,
 		client: &http.Client{
 			Timeout: 10 * time.Second,
 		},
 	}
 }
 
-func (c *CmsClient) RequestSubnet(subnet string) (*NewSubnetRequest, error) {
+func (c *CmsClient) RequestDeleteInstance(ip string) (*CmsDeleteInstanceResponse, error) {
 	log := util.GetLogger()
 
 	reqURL := fmt.Sprintf("http://%s/New/Instance", c.baseURL)
-	reqBody := subnetRequest{Subnet: subnet}
-	jsonBody, err := json.Marshal(reqBody)
+	jsonBody, err := json.Marshal(cmsDeleteInstanceRequestBody{IP: ip})
 	if err != nil {
-		log.Error("CMS : failed to marshal JSON: %v", err)
-		return nil, fmt.Errorf("RequestSubnet: failed to marshal JSON: %w", err)
+		log.Error("CmsClient.RequestDeleteInstance : failed to marshal JSON: %v", err)
+		return nil, fmt.Errorf("CmsClient.RequestDeleteInstance: failed to marshal JSON: %w", err)
 	}
+	req, err := http.NewRequest("DELETE", reqURL, bytes.NewBuffer(jsonBody))
+	if err != nil {
+		log.Error("CmsClient.RequestDeleteInstance : failed to NewRequest: %v", err)
+		return nil, fmt.Errorf("CmsClient.RequestDeleteInstance: failed to create HTTP request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
 
-	req, err := http.NewRequest("POST", reqURL, bytes.NewBuffer(jsonBody))
+	log.DebugInfo("Making request to: %s", reqURL)
+	log.DebugInfo("Request body: %s", string(jsonBody))
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		log.Error("CmsClient.RequestDeleteInstance : failed to send request: %v", err)
+		return nil, fmt.Errorf("CmsClient.RequestDeleteInstance: failed to send request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		log.Error("CmsClient.RequestDeleteInstance : CMS returned status: %s", resp.Status)
+		return nil, fmt.Errorf("CmsClient.RequestDeleteInstance: CMS server returned non-OK status: %s", resp.Status)
+	}
+
+	var addrResp CmsDeleteInstanceResponse
+	if err := json.NewDecoder(resp.Body).Decode(&addrResp); err != nil {
+		log.Error("CmsClient.RequestDeleteInstance : failed to decode CMS response: %v", err)
+		return nil, fmt.Errorf("CmsClient.RequestDeleteInstance: failed to decode response: %w", err)
+	}
+	return &addrResp, nil
+}
+
+// RequestNewInstance는 주어진 서브넷에 대해 CMS에 새 인스턴스 할당을 요청한다.
+func (c *CmsClient) RequestNewInstance(subnet string) (*CmsNewInstanceResponse, error) {
+	log := util.GetLogger()
+
+	reqURL := fmt.Sprintf("http://%s/New/Instance", c.baseURL)
+	jsonBody, err := json.Marshal(cmsNewInstanceRequestBody{Subnet: subnet})
 	if err != nil {
-		log.Error("CMS : failed to NewRequest: %v", err)
-		return nil, fmt.Errorf("RequestSubnet: failed to create HTTP request: %w", err)
+		log.Error("CmsClient.RequestNewInstance : failed to marshal JSON: %v", err)
+		return nil, fmt.Errorf("CmsClient.RequestNewInstance: failed to marshal JSON: %w", err)
 	}
 
+	req, err := http.NewRequest("POST", reqURL, bytes.NewBuffer(jsonBody))
+	if err != nil {
+		log.Error("CmsClient.RequestNewInstance : failed to NewRequest: %v", err)
+		return nil, fmt.Errorf("CmsClient.RequestNewInstance: failed to create HTTP request: %w", err)
+	}
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Accept", "application/json")
 
@@ -67,21 +115,20 @@ func (c *CmsClient) RequestSubnet(subnet string) (*NewSubnetRequest, error) {
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		log.Error("CMS : failed to send request: %v", err)
-		return nil, fmt.Errorf("RequestSubnet: failed to send request: %w", err)
+		log.Error("CmsClient.RequestNewInstance : failed to send request: %v", err)
+		return nil, fmt.Errorf("CmsClient.RequestNewInstance: failed to send request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		log.Error("CMS : CMS returned status: %s", resp.Status)
-		return nil, fmt.Errorf("CMS server returned non-OK status: %s", resp.Status)
+		log.Error("CmsClient.RequestNewInstance : CMS returned status: %s", resp.Status)
+		return nil, fmt.Errorf("CmsClient.RequestNewInstance: CMS server returned non-OK status: %s", resp.Status)
 	}
 
-	var addrResp NewSubnetRequest
+	var addrResp CmsNewInstanceResponse
 	if err := json.NewDecoder(resp.Body).Decode(&addrResp); err != nil {
-		log.Error("CMS : failed to decode CMS response: %v", err)
-		return nil, fmt.Errorf("RequestSubnet: failed to decode response: %w", err)
+		log.Error("CmsClient.RequestNewInstance : failed to decode CMS response: %v", err)
+		return nil, fmt.Errorf("CmsClient.RequestNewInstance: failed to decode response: %w", err)
 	}
-
 	return &addrResp, nil
 }

main.go

@@ -30,7 +30,7 @@ func main() {
 		log.Error("Failed to initialize: %v", err, true)
 		panic(err)
 	}
-	printCores(contextStruct.Cores)
+	printCores(contextStruct.Resources.Cores)
 
 	go func() {
 		err := api.Server(contextStruct.Config.Port, &contextStruct, rdb)

service/cleanup.go

@@ -0,0 +1,20 @@
+package service
+
+// cleanupChain will execute registered cleanup functions in reverse order when run() is called.
+// cleanup chain will register cleanup functions for each step of the process,
+// so that if any step fails, all previous steps can be undone to maintain system consistency.
+type cleanupChain struct {
+	steps []func()
+}
+
+func (c *cleanupChain) push(fn func()) {
+	c.steps = append(c.steps, fn)
+}
+
+func (c *cleanupChain) run() {
+	for i := len(c.steps) - 1; i >= 0; i-- {
+		c.steps[i]()
+	}
+	//for Idempotency
+	c.steps = nil
+}

service/dto.go

@@ -0,0 +1,69 @@
+package service
+
+import (
+	vms "github.com/easy-cloud-Knet/KWS_Control/structure"
+)
+
+// Service Layer DTO.
+// DTOs for service layer to decouple API layer from internal implementation details.
+// API Handler will convert API layer DTOs to service layer DTOs.
+// Service layer will convert to internal client/model structures as needed.
+//
+
+type CreateVMInput struct {
+	UUID         vms.UUID
+	DomType      string
+	DomName      string
+	OS           string
+	HardwareInfo HardwareSpec
+	Network      NetworkSpec
+	Users        []UserSpec
+	SubnetType   string // "Add" 또는 그 외(=신규 서브넷)
+}
+
+type HardwareSpec struct {
+	CPU    uint32
+	Memory uint32 // MiB
+	Disk   uint32 // MiB
+}
+
+type NetworkSpec struct {
+	IPs []string
+}
+
+type UserSpec struct {
+	Name              string
+	Groups            string
+	Password          string
+	SSHAuthorizedKeys []string
+}
+
+// Output DTOs
+type VMInfo struct {
+	UUID   vms.UUID
+	CPU    uint32
+	Memory uint32 // MiB
+	Disk   uint32 // MiB
+	IP     string
+	Status string
+}
+
+type VMCpuStatus struct {
+	System float64
+	Idle   float64
+	Usage  float64
+}
+
+type VMMemoryStatus struct {
+	Total       uint64
+	Used        uint64
+	Available   uint64
+	UsedPercent float64
+}
+
+type VMDiskStatus struct {
+	Total       uint64
+	Used        uint64
+	Free        uint64
+	UsedPercent float64
+}

service/guacamole.go

@@ -14,9 +14,9 @@ func GetGuacamoleToken(uuid structure.UUID, ctx *structure.ControlContext) (stri
 		return "", structure.ErrCoreNotFound(uuid)
 	}
 
-	ctx.RLock()
+	ctx.Resources.RLock()
 	vm, exists := core.VMInfoIdx[uuid]
-	ctx.RUnlock()
+	ctx.Resources.RUnlock()
 
 	if exists {
 		guacClient := client.NewGuacamoleClient(&ctx.Config)