Add virtxml helper and internal status puller

DomCon/domainList_status/updator.go

@@ -3,51 +3,29 @@ package domListStatus
 import (
 	"fmt"
 
-	domainStatus "github.com/easy-cloud-Knet/KWS_Core/DomCon/domain_status"
+	instatus "github.com/easy-cloud-Knet/KWS_Core/internal/status"
 	"go.uber.org/zap"
 	"libvirt.org/go/libvirt"
 )
 
-func (dls *DomainListStatus) UpdateFromDomain(dataDog domainStatus.DataDog, dom *libvirt.Domain, state libvirt.ConnectListAllDomainsFlags, sourceType []domainStatus.SourceType, logger *zap.Logger) error {
-	result, err := dataDog.RetrieveStatus(dom, sourceType, logger)
+func (dls *DomainListStatus) UpdateFromDomain(dataDog instatus.StatusRetriever, isActive bool, sources map[instatus.SourceType]int, logger *zap.Logger) error {
+	statusMap, err := dataDog.RetrieveStatus(sources, logger)
 	if err != nil {
 		return err
 	}
-	statusMap, ok := result.(map[domainStatus.SourceType]int)
-	if !ok {
-		return fmt.Errorf("unexpected status type from domain retrieval")
-	}
-	if cpu, ok := statusMap[domainStatus.CPU]; ok {
+	if cpu, ok := statusMap[instatus.CPU]; ok {
 		dls.AddAllocatedCPU(cpu)
-		if state == libvirt.CONNECT_LIST_DOMAINS_INACTIVE {
+		if !isActive {
 			dls.AddSleepingCPU(cpu)
 		}
 	}
 	return nil
 }
 
-func (dls *DomainListStatus) NewDataDogs(state libvirt.ConnectListAllDomainsFlags) domainStatus.DataDog {
-	switch state {
-	case libvirt.CONNECT_LIST_DOMAINS_ACTIVE:
-		return &domainStatus.LibvirtStatus{}
-	case libvirt.CONNECT_LIST_DOMAINS_INACTIVE:
-		return &domainStatus.XMLStatus{}
-	default:
-		return nil
-	}
-}
-
-func (dls *DomainListStatus) GetDomStatus(dom *libvirt.Domain, sourceType []domainStatus.SourceType, logger *zap.Logger) (interface{}, error) {
-	state, _, err := dom.GetState()
+func (dls *DomainListStatus) GetDomStatus(dom *libvirt.Domain, sources map[instatus.SourceType]int, logger *zap.Logger) (map[instatus.SourceType]int, error) {
+	isActive, err := dom.IsActive()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get domain state: %w", err)
 	}
-	// enum 이고 상태값만 봐선 호환될 거 같긴한데
-	// 한번 봐야됨, ConnectListAllDomainsFlags <-> DomainState
-	dataDog := dls.NewDataDogs(libvirt.ConnectListAllDomainsFlags(state))
-	if dataDog == nil {
-		return nil, fmt.Errorf("unsupported domain state: %d", state)
-	}
-	return dataDog.RetrieveStatus(dom, sourceType, logger)
-
+	return instatus.New(dom, isActive).RetrieveStatus(sources, logger)
 }

DomCon/domainList_status/updator_test.go

@@ -0,0 +1,63 @@
+package domListStatus
+
+import (
+	"fmt"
+	"testing"
+
+	instatus "github.com/easy-cloud-Knet/KWS_Core/internal/status"
+	"go.uber.org/zap"
+)
+
+type mockStatusRetriever struct {
+	result map[instatus.SourceType]int
+	err    error
+}
+
+func (m *mockStatusRetriever) RetrieveStatus(_ map[instatus.SourceType]int, _ *zap.Logger) (map[instatus.SourceType]int, error) {
+	return m.result, m.err
+}
+
+var nopLogger = zap.NewNop()
+
+func TestUpdateFromDomain_ActiveIncreasesAllocated(t *testing.T) {
+	dls := &DomainListStatus{}
+	mock := &mockStatusRetriever{result: map[instatus.SourceType]int{instatus.CPU: 4}}
+
+	if err := dls.UpdateFromDomain(mock, true, map[instatus.SourceType]int{instatus.CPU: 0}, nopLogger); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if dls.VcpuAllocated != 4 {
+		t.Errorf("expected VcpuAllocated=4, got %d", dls.VcpuAllocated)
+	}
+	if dls.VcpuSleeping != 0 {
+		t.Errorf("expected VcpuSleeping=0 for active domain, got %d", dls.VcpuSleeping)
+	}
+}
+
+func TestUpdateFromDomain_InactiveIncreasesBoth(t *testing.T) {
+	dls := &DomainListStatus{}
+	mock := &mockStatusRetriever{result: map[instatus.SourceType]int{instatus.CPU: 4}}
+
+	if err := dls.UpdateFromDomain(mock, false, map[instatus.SourceType]int{instatus.CPU: 0}, nopLogger); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if dls.VcpuAllocated != 4 {
+		t.Errorf("expected VcpuAllocated=4, got %d", dls.VcpuAllocated)
+	}
+	if dls.VcpuSleeping != 4 {
+		t.Errorf("expected VcpuSleeping=4 for inactive domain, got %d", dls.VcpuSleeping)
+	}
+}
+
+func TestUpdateFromDomain_StatusRetrieverError(t *testing.T) {
+	dls := &DomainListStatus{}
+	mock := &mockStatusRetriever{err: fmt.Errorf("retrieval error")}
+
+	err := dls.UpdateFromDomain(mock, true, map[instatus.SourceType]int{instatus.CPU: 0}, nopLogger)
+	if err == nil {
+		t.Error("expected error from StatusRetriever, got nil")
+	}
+	if dls.VcpuAllocated != 0 {
+		t.Errorf("expected no CPU change on error, got %d", dls.VcpuAllocated)
+	}
+}

DomCon/domain_list.go

@@ -5,8 +5,8 @@ import (
 	"sync"
 
 	domStatus "github.com/easy-cloud-Knet/KWS_Core/DomCon/domainList_status"
-	domainStatus "github.com/easy-cloud-Knet/KWS_Core/DomCon/domain_status"
 	virerr "github.com/easy-cloud-Knet/KWS_Core/internal/error"
+	instatus "github.com/easy-cloud-Knet/KWS_Core/internal/status"
 	"go.uber.org/zap"
 	"libvirt.org/go/libvirt"
 )
@@ -112,7 +112,7 @@ func (DC *DomListControl) retrieveDomainsByState(state libvirt.ConnectListAllDom
 		return err
 	}
 
-	dataDog := DC.DomainListStatus.NewDataDogs(state)
+	isActive := state == libvirt.CONNECT_LIST_DOMAINS_ACTIVE
 	wg := &sync.WaitGroup{}
 	for _, dom := range domains {
 		uuid, err := dom.GetUUIDString()
@@ -127,12 +127,14 @@ func (DC *DomListControl) retrieveDomainsByState(state libvirt.ConnectListAllDom
 		DC.AddExistingDomain(NewDom, uuid)
 
 		wg.Add(1)
-		go func(targetDom libvirt.Domain) {
+		go func(targetDom libvirt.Domain, targetUUID string) {
 			defer wg.Done()
-			if err := DC.DomainListStatus.UpdateFromDomain(dataDog, &targetDom, state, []domainStatus.SourceType{domainStatus.CPU}, logger); err != nil {
-				logger.Sugar().Errorf("Failed to retrieve status for domain UUID=%s: %v", uuid, err)
+			dataDog := instatus.New(&targetDom, isActive)
+			sources := map[instatus.SourceType]int{instatus.CPU: 0}
+			if err := DC.DomainListStatus.UpdateFromDomain(dataDog, isActive, sources, logger); err != nil {
+				logger.Sugar().Errorf("Failed to retrieve status for domain UUID=%s: %v", targetUUID, err)
 			}
-		}(dom)
+		}(dom, uuid)
 		logger.Sugar().Infof("Added domain: UUID=%s", uuid)
 	}
 	wg.Wait()

api/Control.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"net/http"
 
-domainStatus "github.com/easy-cloud-Knet/KWS_Core/DomCon/domain_status"
 	virerr "github.com/easy-cloud-Knet/KWS_Core/internal/error"
+	instatus "github.com/easy-cloud-Knet/KWS_Core/internal/status"
 	httputil "github.com/easy-cloud-Knet/KWS_Core/pkg/httputil"
 	"github.com/easy-cloud-Knet/KWS_Core/services/termination"
 	"go.uber.org/zap"
@@ -41,7 +41,8 @@ func (i *InstHandler) ForceShutDownVM(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	stat, err := i.DomainControl.DomainListStatus.GetDomStatus(dom.Domain, []domainStatus.SourceType{domainStatus.CPU}, i.Logger)
+	sources := map[instatus.SourceType]int{instatus.CPU: 0}
+	stat, err := i.DomainControl.DomainListStatus.GetDomStatus(dom.Domain, sources, i.Logger)
 	if err != nil {
 		ERR := virerr.ErrorJoin(err, fmt.Errorf("error getting domain status for forceShutdown"))
 		resp.ResponseWriteErr(w, ERR, http.StatusInternalServerError)
@@ -50,7 +51,7 @@ func (i *InstHandler) ForceShutDownVM(w http.ResponseWriter, r *http.Request) {
 	}
 	i.Logger.Info("Domain status retrieved", zap.Any("status", stat))
 
-	i.DomainControl.DomainListStatus.AddSleepingCPU(int(stat.(map[domainStatus.SourceType]int)[domainStatus.CPU]))
+	i.DomainControl.DomainListStatus.AddSleepingCPU(stat[instatus.CPU])
 
 	resp.ResponseWriteOK(w, nil)
 }
@@ -73,7 +74,8 @@ func (i *InstHandler) DeleteVM(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	stat, err := i.DomainControl.DomainListStatus.GetDomStatus(domain.Domain, []domainStatus.SourceType{domainStatus.CPU}, i.Logger)
+	sources := map[instatus.SourceType]int{instatus.CPU: 0}
+	stat, err := i.DomainControl.DomainListStatus.GetDomStatus(domain.Domain, sources, i.Logger)
 	if err != nil {
 		ERR := virerr.ErrorJoin(err, fmt.Errorf("error getting domain status for deleteVM"))
 		resp.ResponseWriteErr(w, ERR, http.StatusInternalServerError)
@@ -89,7 +91,7 @@ func (i *InstHandler) DeleteVM(w http.ResponseWriter, r *http.Request) {
 		i.Logger.Error("failed to delete domain", zap.String("uuid", param.UUID), zap.Error(ERR))
 		return
 	}
-	i.DomainControl.DeleteDomain(domain.Domain, param.UUID, int(stat.(map[domainStatus.SourceType]int)[domainStatus.CPU]))
+	i.DomainControl.DeleteDomain(domain.Domain, param.UUID, stat[instatus.CPU])
 
 	resp.ResponseWriteOK(w, nil)
 }

internal/status/datadog.go

@@ -0,0 +1,21 @@
+package status
+
+import (
+	"go.uber.org/zap"
+)
+
+type StatusRetriever interface {
+	RetrieveStatus(map[SourceType]int, *zap.Logger) (map[SourceType]int, error)
+}
+
+type statusDomain interface {
+	libvirtDom
+	xmlDom
+}
+
+func New(dom statusDomain, isActive bool) StatusRetriever {
+	if isActive {
+		return &LibvirtStatus{dom: dom}
+	}
+	return &XMLStatus{dom: dom}
+}