refactor: reduce code complexity by eliminating duplication and simplifying methods

Complexity Reductions:
- Extract common initialization logic into createStoreExtManager() helper
- Break down complex Start() method into focused single-purpose functions:
  - getPlatformBinaryName(): Handle platform-specific binary naming
  - resolveBinaryPath(): Locate extension binary with clear error handling
  - downloadExtensionAsync(): Handle extension download in background
- Simplify AI health check methods with helper functions:
  - copyHealthInfo(): Dedicated health info copying
  - getRegisteredPlugins(): Safe plugin registry access
  - createErrorHealth(): Consistent error health creation
- Remove conditional duplication in TypeScript API functions
- Improve error handling with early returns and clearer logic flow

These changes significantly reduce cyclomatic complexity while maintaining
the same functionality and improving code maintainability.

Author: KariHall619

console/atest-ui/src/views/net.ts

@@ -153,14 +153,9 @@ async function GetSchema(name: string, callback?: (v: CommonResult) => void) {
     const requestOptions = {
         method: 'GET',
     }
-    if (callback) {
-        return fetch(`/api/v1/schemas/${name}`, requestOptions)
-            .then(DefaultResponseProcess)
-            .then(emptyOrDefault(callback))
-    } else {
-        return fetch(`/api/v1/schemas/${name}`, requestOptions)
-            .then(DefaultResponseProcess)
-    }
+    return fetch(`/api/v1/schemas/${name}`, requestOptions)
+        .then(DefaultResponseProcess)
+        .then(emptyOrDefault(callback))
 }
 
 interface TestSuite {
@@ -600,13 +595,9 @@ interface StoreKindsResponse {
 }
 
 const GetStoreKinds = (callback?: (d: StoreKindsResponse) => void | null, errHandle?: (e: any) => void | null) => {
-    if (callback) {
-        return fetch(`/api/v1/stores/kinds`, {})
-            .then(DefaultResponseProcess)
-            .then(callback).catch(emptyOrDefault(errHandle))
-    }
     return fetch(`/api/v1/stores/kinds`, {})
         .then(DefaultResponseProcess)
+        .then(callback ? callback : () => {})
         .catch(emptyOrDefault(errHandle))
 }
 

pkg/server/store_ext_manager.go

@@ -93,49 +93,35 @@ type storeExtManager struct {
 
 var ss *storeExtManager
 
-func NewStoreExtManager(execer fakeruntime.Execer) ExtManager {
-	if ss == nil {
-		ctx, cancel := context.WithCancel(context.Background())
-		ss = &storeExtManager{
-			processChan: make(chan fakeruntime.Process),
-			stopSingal:  make(chan struct{}, 1),
-			lock:        &sync.RWMutex{},
-			// AI Plugin Management initialization
-			aiPluginRegistry:  make(map[string]AIPluginInfo),
-			aiPluginHealthMap: make(map[string]*AIPluginHealth),
-			healthCheckCtx:    ctx,
-			healthCheckCancel: cancel,
-		}
-		ss.execer = execer
-		ss.socketPrefix = "unix://"
-		ss.extStatusMap = map[string]bool{}
-		ss.processCollect()
-		ss.WithDownloader(&nonDownloader{})
-		// Start AI plugin health monitoring
-		ss.startAIHealthMonitoring()
-	}
-	return ss
-}
-
-func NewStoreExtManagerInstance(execer fakeruntime.Execer) ExtManager {
+func createStoreExtManager(execer fakeruntime.Execer) *storeExtManager {
 	ctx, cancel := context.WithCancel(context.Background())
-	ss = &storeExtManager{
+	manager := &storeExtManager{
 		processChan: make(chan fakeruntime.Process),
 		stopSingal:  make(chan struct{}, 1),
 		lock:        &sync.RWMutex{},
-		// AI Plugin Management initialization
 		aiPluginRegistry:  make(map[string]AIPluginInfo),
 		aiPluginHealthMap: make(map[string]*AIPluginHealth),
 		healthCheckCtx:    ctx,
 		healthCheckCancel: cancel,
+		execer:            execer,
+		socketPrefix:      "unix://",
+		extStatusMap:      map[string]bool{},
+	}
+	manager.processCollect()
+	manager.WithDownloader(&nonDownloader{})
+	manager.startAIHealthMonitoring()
+	return manager
+}
+
+func NewStoreExtManager(execer fakeruntime.Execer) ExtManager {
+	if ss == nil {
+		ss = createStoreExtManager(execer)
 	}
-	ss.execer = execer
-	ss.socketPrefix = "unix://"
-	ss.extStatusMap = map[string]bool{}
-	ss.processCollect()
-	ss.WithDownloader(&nonDownloader{})
-	// Start AI plugin health monitoring
-	ss.startAIHealthMonitoring()
+	return ss
+}
+
+func NewStoreExtManagerInstance(execer fakeruntime.Execer) ExtManager {
+	ss = createStoreExtManager(execer)
 	return ss
 }
 
@@ -145,60 +131,75 @@ func (s *storeExtManager) StartPlugin(storeKind testing.StoreKind) {
 	}
 }
 
+func (s *storeExtManager) getPlatformBinaryName(name string) string {
+	if s.execer.OS() == "windows" {
+		return name + ".exe"
+	}
+	return name
+}
+
+func (s *storeExtManager) resolveBinaryPath(name string) (string, error) {
+	platformBasedName := s.getPlatformBinaryName(name)
+	targetDir := home.GetUserBinDir()
+	targetBinaryFile := filepath.Join(targetDir, platformBasedName)
+
+	if _, err := os.Stat(targetBinaryFile); err == nil {
+		return targetBinaryFile, nil
+	}
+
+	serverLogger.Info("failed to find extension locally, looking in PATH", "name", name)
+	binaryPath, err := s.execer.LookPath(platformBasedName)
+	if err != nil {
+		return "", fmt.Errorf("not found extension, try to download it, error: %v", err)
+	}
+	return binaryPath, nil
+}
+
+func (s *storeExtManager) downloadExtensionAsync(name, socket string) {
+	go func() {
+		ociDownloader := downloader.NewStoreDownloader()
+		ociDownloader.WithKind("store")
+		ociDownloader.WithOS(s.execer.OS())
+		reader, dErr := ociDownloader.Download(name, "", "")
+		if dErr != nil {
+			serverLogger.Error(dErr, "failed to download extension", "name", name)
+			return
+		}
+
+		extFile := ociDownloader.GetTargetFile()
+		targetDir := home.GetUserBinDir()
+		targetFile := filepath.Base(extFile)
+		if dErr = downloader.WriteTo(reader, targetDir, targetFile); dErr == nil {
+			binaryPath := filepath.Join(targetDir, targetFile)
+			s.startPlugin(socket, binaryPath, name)
+		} else {
+			serverLogger.Error(dErr, "failed to save extension", "targetFile", targetFile)
+		}
+	}()
+}
+
 func (s *storeExtManager) Start(name, socket string) (err error) {
 	if name == "" {
+		return nil
 	}
 
 	serverLogger.Info("start", "extension", name, "socket", socket)
 	if v, ok := s.extStatusMap[name]; ok && v {
-		return
+		return nil
 	}
 
-	platformBasedName := name
-	if s.execer.OS() == "windows" {
-		platformBasedName += ".exe"
-	} else {
+	if s.execer.OS() != "windows" {
 		socket = fmt.Sprintf("unix://%s", home.GetExtensionSocketPath(name))
 	}
 
-	targetDir := home.GetUserBinDir()
-	targetBinaryFile := filepath.Join(targetDir, platformBasedName)
-
-	var binaryPath string
-	if _, err = os.Stat(targetBinaryFile); err == nil {
-		binaryPath = targetBinaryFile
-	} else {
-		serverLogger.Info("failed to find extension", "error", err.Error())
-
-		binaryPath, err = s.execer.LookPath(platformBasedName)
-		if err != nil {
-			err = fmt.Errorf("not found extension, try to download it, error: %v", err)
-			go func() {
-				ociDownloader := downloader.NewStoreDownloader()
-				ociDownloader.WithKind("store")
-				ociDownloader.WithOS(s.execer.OS())
-				reader, dErr := ociDownloader.Download(name, "", "")
-				if dErr != nil {
-					serverLogger.Error(dErr, "failed to download extension", "name", name)
-				} else {
-					extFile := ociDownloader.GetTargetFile()
-
-					targetFile := filepath.Base(extFile)
-					if dErr = downloader.WriteTo(reader, targetDir, targetFile); dErr == nil {
-						binaryPath = filepath.Join(targetDir, targetFile)
-						s.startPlugin(socket, binaryPath, name)
-					} else {
-						serverLogger.Error(dErr, "failed to save extension", "targetFile", targetFile)
-					}
-				}
-			}()
-		}
+	binaryPath, err := s.resolveBinaryPath(name)
+	if err != nil {
+		s.downloadExtensionAsync(name, socket)
+		return err
 	}
 
-	if err == nil {
-		go s.startPlugin(socket, binaryPath, name)
-	}
-	return
+	go s.startPlugin(socket, binaryPath, name)
+	return nil
 }
 
 func (s *storeExtManager) startPlugin(socketURL, plugin, pluginName string) (err error) {
@@ -320,25 +321,34 @@ func (s *storeExtManager) startAIHealthMonitoring() {
 	}()
 }
 
-// performHealthCheck performs health checks on all registered AI plugins
-func (s *storeExtManager) performHealthCheck() {
+func (s *storeExtManager) getRegisteredPlugins() map[string]AIPluginInfo {
 	s.lock.RLock()
+	defer s.lock.RUnlock()
 	plugins := make(map[string]AIPluginInfo)
 	for name, info := range s.aiPluginRegistry {
 		plugins[name] = info
 	}
-	s.lock.RUnlock()
+	return plugins
+}
+
+func (s *storeExtManager) createErrorHealth(name string, err error) *AIPluginHealth {
+	return &AIPluginHealth{
+		Name:         name,
+		Status:       "error",
+		LastCheckAt:  time.Now(),
+		ErrorMessage: err.Error(),
+	}
+}
+
+// performHealthCheck performs health checks on all registered AI plugins
+func (s *storeExtManager) performHealthCheck() {
+	plugins := s.getRegisteredPlugins()
 
 	for name, info := range plugins {
 		health, err := s.checkSingleAIPlugin(info)
 		if err != nil {
 			serverLogger.Error(err, "Failed to check AI plugin health", "plugin", name)
-			health = &AIPluginHealth{
-				Name:         name,
-				Status:       "error",
-				LastCheckAt:  time.Now(),
-				ErrorMessage: err.Error(),
-			}
+			health = s.createErrorHealth(name, err)
 		}
 
 		s.lock.Lock()
@@ -419,30 +429,29 @@ func (s *storeExtManager) CheckAIPluginHealth(name string) (*AIPluginHealth, err
 	return health, nil
 }
 
+func (s *storeExtManager) copyHealthInfo(health *AIPluginHealth) *AIPluginHealth {
+	copy := &AIPluginHealth{
+		Name:         health.Name,
+		Status:       health.Status,
+		LastCheckAt:  health.LastCheckAt,
+		ResponseTime: health.ResponseTime,
+		ErrorMessage: health.ErrorMessage,
+		Metrics:      make(map[string]string),
+	}
+	for k, v := range health.Metrics {
+		copy.Metrics[k] = v
+	}
+	return copy
+}
+
 // GetAllAIPluginHealth returns the health status of all AI plugins
 func (s *storeExtManager) GetAllAIPluginHealth() (map[string]*AIPluginHealth, error) {
 	s.lock.RLock()
 	defer s.lock.RUnlock()
 
-	// Return a copy to avoid concurrent access issues
 	healthMap := make(map[string]*AIPluginHealth)
 	for name, health := range s.aiPluginHealthMap {
-		// Create a copy of the health struct
-		healthCopy := &AIPluginHealth{
-			Name:         health.Name,
-			Status:       health.Status,
-			LastCheckAt:  health.LastCheckAt,
-			ResponseTime: health.ResponseTime,
-			ErrorMessage: health.ErrorMessage,
-			Metrics:      make(map[string]string),
-		}
-		
-		// Copy metrics map
-		for k, v := range health.Metrics {
-			healthCopy.Metrics[k] = v
-		}
-		
-		healthMap[name] = healthCopy
+		healthMap[name] = s.copyHealthInfo(health)
 	}
 
 	return healthMap, nil