feat: Load scan services dynamically based on configuration properties

src/main/java/com/lpvs/service/LPVSQueueService.java

@@ -12,6 +12,7 @@
 import com.lpvs.entity.enums.LPVSPullRequestStatus;
 import com.lpvs.repository.LPVSPullRequestRepository;
 import com.lpvs.repository.LPVSQueueRepository;
+import com.lpvs.service.scan.LPVSDetectService;
 import com.lpvs.util.LPVSWebhookUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;

src/main/java/com/lpvs/service/LPVSDetectService.java → src/main/java/com/lpvs/service/scan/LPVSDetectService.java

@@ -4,14 +4,17 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-package com.lpvs.service;
+package com.lpvs.service.scan;
 
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 
+import com.lpvs.service.LPVSGitHubConnectionService;
+import com.lpvs.service.LPVSGitHubService;
+import com.lpvs.service.LPVSLicenseService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.SpringApplication;
@@ -23,10 +26,8 @@
 
 import com.lpvs.entity.LPVSFile;
 import com.lpvs.entity.LPVSQueue;
-import com.lpvs.service.scanner.scanoss.LPVSScanossDetectService;
 import com.lpvs.util.LPVSCommentUtil;
 
-import jakarta.annotation.PostConstruct;
 import lombok.extern.slf4j.Slf4j;
 
 /**
@@ -36,16 +37,6 @@
 @Slf4j
 public class LPVSDetectService {
 
-    /**
-     * The type of license detection scanner.
-     */
-    private String scannerType;
-
-    /**
-     * Service responsible for performing license detection using the ScanOSS scanner.
-     */
-    private LPVSScanossDetectService scanossDetectService;
-
     /**
      * Service responsible for establishing and managing connections to the GitHub API.
      */
@@ -61,6 +52,11 @@ public class LPVSDetectService {
      */
     private LPVSGitHubService gitHubService;
 
+    /**
+     * Service responsible for initialization of the scanner.
+     */
+    private LPVSScanService scanService;
+
     /**
      * GitHub pull request used to trigger a single license scan (optional).
      */
@@ -82,29 +78,24 @@ public class LPVSDetectService {
      * Constructs an instance of LPVSDetectService with the specified parameters.
      *
      * @param scannerType             The type of license detection scanner.
+     * @param isInternal              Flag indicating whether the scanner is internal or not.
      * @param gitHubConnectionService Service for connecting to the GitHub API.
-     * @param scanossDetectService    Service for license detection using ScanOSS.
      * @param licenseService          Service for license conflict analysis.
      * @param gitHubService           Service for GitHub connection and operation.
+     * @param scanServiceFactory      Service for creating instance of the scanner.
      */
+    @Autowired
     public LPVSDetectService(
             @Value("${scanner:scanoss}") String scannerType,
+            @Value("${internal:false}") boolean isInternal,
             LPVSGitHubConnectionService gitHubConnectionService,
-            LPVSScanossDetectService scanossDetectService,
             LPVSLicenseService licenseService,
-            LPVSGitHubService gitHubService) {
-        this.scannerType = scannerType;
+            LPVSGitHubService gitHubService,
+            LPVSScanServiceFactory scanServiceFactory) {
         this.gitHubConnectionService = gitHubConnectionService;
-        this.scanossDetectService = scanossDetectService;
         this.licenseService = licenseService;
         this.gitHubService = gitHubService;
-    }
-
-    /**
-     * Initializes the LPVSDetectService bean and logs the selected license detection scanner.
-     */
-    @PostConstruct
-    private void init() {
+        this.scanService = scanServiceFactory.createScanService(scannerType, isInternal);
         log.info("License detection scanner: " + scannerType);
     }
 
@@ -166,10 +157,12 @@ public void runOneScan() {
      * @throws Exception if an error occurs during the scan.
      */
     public List<LPVSFile> runScan(LPVSQueue webhookConfig, String path) throws Exception {
-        if (scannerType.equals("scanoss")) {
-            scanossDetectService.runScan(webhookConfig, path);
-            return scanossDetectService.checkLicenses(webhookConfig);
+        try {
+            scanService.runScan(webhookConfig, path);
+            return scanService.checkLicenses(webhookConfig);
+        } catch (IllegalArgumentException | NullPointerException ex) {
+            log.error(ex.getMessage());
+            return new ArrayList<>();
         }
-        return new ArrayList<>();
     }
 }

src/main/java/com/lpvs/service/scan/LPVSScanService.java

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2024, Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+package com.lpvs.service.scan;
+
+import com.lpvs.entity.LPVSFile;
+import com.lpvs.entity.LPVSQueue;
+
+import java.util.List;
+
+/**
+ * Interface representing a service for scanning files and checking licenses.
+ */
+public interface LPVSScanService {
+
+    /**
+     * Runs a scan on the specified path using the provided webhook configuration.
+     *
+     * @param webhookConfig The webhook configuration to use for the scan.
+     * @param path          The path to the file or directory to scan.
+     * @throws Exception if an error occurs during the scan process.
+     */
+    void runScan(LPVSQueue webhookConfig, String path) throws Exception;
+
+    /**
+     * Checks licenses for files using the provided webhook configuration.
+     *
+     * @param webhookConfig The webhook configuration to use for checking licenses.
+     * @return A list of LPVSFile objects representing files with detected licenses.
+     */
+    List<LPVSFile> checkLicenses(LPVSQueue webhookConfig);
+}

src/main/java/com/lpvs/service/scan/LPVSScanServiceFactory.java

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2024, Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+package com.lpvs.service.scan;
+
+import com.lpvs.repository.LPVSLicenseRepository;
+import com.lpvs.service.LPVSLicenseService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.lang.reflect.Constructor;
+
+/**
+ * Factory class for creating instances of {@link LPVSScanService}.
+ */
+@Service
+public class LPVSScanServiceFactory {
+
+    /**
+     * Flag indicating whether the application is in debug mode.
+     */
+    @Value("${debug:false}")
+    Boolean debug;
+
+    /**
+     * The service for managing licenses, providing operations related to licenses.
+     */
+    @Autowired LPVSLicenseService licenseService;
+
+    /**
+     * The repository for LPVSLicense entities, allowing database interactions for licenses.
+     */
+    @Autowired LPVSLicenseRepository lpvsLicenseRepository;
+
+    /**
+     * Creates a scan service based on the specified scanner type and configuration.
+     *
+     * @param scannerType The type of scanner to create.
+     * @param isInternal  Flag indicating whether the scanner is internal or not.
+     * @return An instance of {@link LPVSScanService} corresponding to the specified scanner type.
+     * @throws IllegalArgumentException if the specified scanner type is not supported or if an error occurs during
+     *                                  the creation process.
+     */
+    public LPVSScanService createScanService(String scannerType, boolean isInternal) {
+        try {
+            Class<?> serviceClass = Class.forName(getServiceClassName(scannerType, isInternal));
+            Constructor<?> constructor =
+                    serviceClass.getDeclaredConstructor(
+                            Boolean.class, LPVSLicenseService.class, LPVSLicenseRepository.class);
+            return (LPVSScanService)
+                    constructor.newInstance(debug, licenseService, lpvsLicenseRepository);
+        } catch (Exception e) {
+            throw new IllegalArgumentException(
+                    "Error creating scan service for type: " + scannerType, e);
+        }
+    }
+
+    /**
+     * Gets the fully qualified class name of the scan service based on the specified scanner type and configuration.
+     *
+     * @param scannerType The type of scanner.
+     * @param isInternal  Flag indicating whether the scanner is internal or not.
+     * @return The fully qualified class name of the scan service.
+     * @throws IllegalArgumentException if the specified scanner type is null or empty string.
+     */
+    protected String getServiceClassName(String scannerType, boolean isInternal) {
+        if (scannerType != null && !scannerType.isEmpty()) {
+            return "com.lpvs."
+                    + (isInternal ? "internal." : "")
+                    + "service.scan.scanner.LPVS"
+                    + scannerType.substring(0, 1).toUpperCase()
+                    + scannerType.substring(1)
+                    + "DetectService";
+        } else {
+            throw new IllegalArgumentException("Scanner type cannot be null or empty.");
+        }
+    }
+}

src/main/java/com/lpvs/service/scan/package-info.java

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2024, Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+/**
+ * Provides services related to scanning operations.
+ * <p>
+ * This package contains classes and interfaces that define services for performing scanning operations,
+ * such as checking licenses, and managing scanning configurations.
+ * </p>
+ */
+package com.lpvs.service.scan;

src/main/java/com/lpvs/service/scanner/scanoss/LPVSScanossDetectService.java → src/main/java/com/lpvs/service/scan/scanner/LPVSScanossDetectService.java

@@ -4,7 +4,7 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-package com.lpvs.service.scanner.scanoss;
+package com.lpvs.service.scan.scanner;
 
 import com.google.gson.*;
 import com.google.gson.reflect.TypeToken;
@@ -13,6 +13,7 @@
 import com.lpvs.entity.LPVSQueue;
 import com.lpvs.repository.LPVSLicenseRepository;
 import com.lpvs.service.LPVSLicenseService;
+import com.lpvs.service.scan.LPVSScanService;
 import com.lpvs.util.LPVSWebhookUtil;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -29,12 +30,12 @@
 import static com.lpvs.util.LPVSFileUtil.getScanResultsJsonFilePath;
 
 /**
- * Service class responsible for interacting with the Scanoss scanner to detect licenses in files.
+ * Service class responsible for interacting with the Scanoss scanner to scan licenses in files.
  * It handles the initiation of the scan, processing scan results, and checking for license conflicts.
  */
 @Service
 @Slf4j
-public class LPVSScanossDetectService {
+public class LPVSScanossDetectService implements LPVSScanService {
 
     /**
      * The service for managing licenses, providing operations related to licenses.

src/main/java/com/lpvs/service/scanner/scanoss/package-info.java → src/main/java/com/lpvs/service/scan/scanner/package-info.java

@@ -6,10 +6,9 @@
  */
 
 /**
- * The {@code scanoss} package contains services and utilities related to the Scanoss scanner integration.
- * Scanoss is a tool used for scanning and analyzing open source software components to detect licenses,
+ * The package contains service related to the Scanoss scanner integration.
+ * Scanoss is a tool used for scanning and analyzing open source software components to scan licenses,
  * vulnerabilities, and other relevant information. This package encapsulates functionality for running
  * Scanoss scans, processing scan results, and handling license-related operations.
- * The package also contains utility classes for handling file paths, reading scan results, and managing licenses.
  */
-package com.lpvs.service.scanner.scanoss;
+package com.lpvs.service.scan.scanner;

src/test/java/com/lpvs/service/LPVSQueueServiceTest.java

@@ -14,6 +14,7 @@
 import com.lpvs.entity.enums.LPVSPullRequestStatus;
 import com.lpvs.repository.LPVSPullRequestRepository;
 import com.lpvs.repository.LPVSQueueRepository;
+import com.lpvs.service.scan.LPVSDetectService;
 import lombok.extern.slf4j.Slf4j;
 
 import org.junit.jupiter.api.AfterEach;