feat: Load service dynamically based on configuration property

Signed-off-by: Oleg Kopysov <[email protected]>

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,16 @@
  * 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 +25,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 +36,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 +51,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 +77,24 @@ public class LPVSDetectService {
      * Constructs an instance of LPVSDetectService with the specified parameters.
      *
      * @param scannerType             The type of license detection scanner.
+     * @param isInternal
      * @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
      */
+    @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 +156,7 @@ 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);
-        }
-        return new ArrayList<>();
+        scanService.runScan(webhookConfig, path);
+        return scanService.checkLicenses(webhookConfig);
     }
 }

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,50 @@
+/**
+ * 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 java.lang.reflect.Constructor;
+
+/**
+ * Factory class for creating instances of {@link LPVSScanService}.
+ */
+public class LPVSScanServiceFactory {
+
+    /**
+     * 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();
+            return (LPVSScanService) constructor.newInstance();
+        } 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.
+     */
+    private 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/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.
@@ -301,16 +302,16 @@ private class ScanossJsonStructure {
         private String matched;
         private String oss_lines;
         private ArrayList<String> purl;
-        private String release_date;
-        private ScanossServer server;
-        private String source_hash;
-        private String status;
-        private String url;
-        private String url_hash;
-        private String vendor;
-        private String version;
+            private String release_date;
+            private ScanossServer server;
+            private String source_hash;
+            private String status;
+            private String url;
+            private String url_hash;
+            private String vendor;
+            private String version;
 
-        private class ScanossLicense {
+            private class ScanossLicense {
             private String checklist_url;
             private String copyleft;
             private ArrayList<String> incompatible_with;

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

@@ -7,9 +7,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,
+ * 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;