Refactor 1

Author: yahavi

src/main/connect/connectionUtils.ts

@@ -178,15 +178,6 @@ export class ConnectionUtils {
         return Promise.resolve('Successfully connected to Xray version: ' + xrayVersion);
     }
 
-    public static async testXrayVersionForScanGraph(jfrogClient: JfrogClient, logger: LogManager): Promise<boolean> {
-        let xrayVersion: string = await this.getXrayVersion(jfrogClient);
-        if (!(await this.isXrayVersionCompatible(xrayVersion, ConnectionUtils.MINIMAL_XRAY_VERSION_SUPPORTED))) {
-            logger.logError(new Error('Dependencies scan is supported only on Xray >= 3.29.0'), true);
-            return false;
-        }
-        return true;
-    }
-
     public static async testXrayEntitlementForFeature(jfrogClient: JfrogClient, feature: EntitlementScanFeature): Promise<boolean> {
         return await jfrogClient
             .xray()

src/main/scanLogic/scanManager.ts

@@ -10,20 +10,15 @@ import { IGraphResponse, XrayScanProgress } from 'jfrog-client-js';
 import { RootNode } from '../treeDataProviders/dependenciesTree/dependenciesRoot/rootTree';
 import { AnalyzerUtils } from '../treeDataProviders/utils/analyzerUtils';
 import { StepProgress } from '../treeDataProviders/utils/stepProgress';
-import { ExcludeScanner, Module } from '../types/jfrogAppsConfig';
-import { AppsConfigUtils } from '../utils/appConfigUtils';
 import { Configuration } from '../utils/configuration';
 import { Resource } from '../utils/resource';
 import { ScanUtils } from '../utils/scanUtils';
 import { Utils } from '../utils/utils';
 import { GraphScanLogic } from './scanGraphLogic';
 import { ApplicabilityRunner, ApplicabilityScanResponse } from './scanRunners/applicabilityScan';
-import { BinaryRunner } from './scanRunners/binaryRunner';
-import { IacRunner, IacScanResponse } from './scanRunners/iacScan';
-import { SastScanResponse, SastRunner } from './scanRunners/sastScan';
-import { SecretsRunner, SecretsScanResponse } from './scanRunners/secretsScan';
+import { JasScanner } from './scanRunners/binaryRunner';
 
-export interface SupportedScans {
+export interface EntitledScans {
     dependencies: boolean;
     applicability: boolean;
     sast: boolean;
@@ -39,7 +34,7 @@ export class ScanManager implements ExtensionComponent {
     private static readonly RESOURCE_CHECK_UPDATE_INTERVAL_MILLISECS: number = 1000 * 60 * 60 * 24;
 
     private static lastOutdatedCheck: number;
-    private _supportedScans: SupportedScans = {} as SupportedScans;
+    private _entitledScans: EntitledScans = {} as EntitledScans;
 
     constructor(private _connectionManager: ConnectionManager, protected _logManager: LogManager) {}
 
@@ -56,16 +51,16 @@ export class ScanManager implements ExtensionComponent {
         return this._connectionManager;
     }
 
-    public get supportedScans(): SupportedScans {
-        return this._supportedScans;
+    public get entitledScans(): EntitledScans {
+        return this._entitledScans;
     }
 
     /**
      * Updates all the resources that are outdated.
      * @param supportedScans - the supported scan to get the needed resources. if default, should call getSupportedScans before calling this method.
      * @returns true if all the outdated resources updated successfully, false otherwise
      */
-    public async updateResources(supportedScans: SupportedScans = this._supportedScans): Promise<boolean> {
+    public async updateResources(supportedScans: EntitledScans = this._entitledScans): Promise<boolean> {
         let result: boolean = true;
         await ScanUtils.backgroundTask(async (progress: vscode.Progress<{ message?: string; increment?: number }>) => {
             progress.report({ message: 'Checking for updates' });
@@ -98,7 +93,7 @@ export class ScanManager implements ExtensionComponent {
         return result;
     }
 
-    private async getOutdatedResources(supportedScans: SupportedScans): Promise<Resource[]> {
+    private async getOutdatedResources(supportedScans: EntitledScans): Promise<Resource[]> {
         if (!this.shouldCheckOutdated()) {
             return [];
         }
@@ -130,23 +125,16 @@ export class ScanManager implements ExtensionComponent {
         return !ScanManager.lastOutdatedCheck || Date.now() - ScanManager.lastOutdatedCheck > ScanManager.RESOURCE_CHECK_UPDATE_INTERVAL_MILLISECS;
     }
 
-    private getResources(supportedScans: SupportedScans): Resource[] {
+    private getResources(supportedScans: EntitledScans): Resource[] {
         let resources: Resource[] = [];
         if (supportedScans.applicability || supportedScans.iac || supportedScans.secrets) {
-            resources.push(BinaryRunner.getAnalyzerManagerResource(this._logManager));
+            resources.push(JasScanner.getAnalyzerManagerResource(this._logManager));
         } else {
             this.logManager.logMessage('You are not entitled to run Advanced Security scans', 'DEBUG');
         }
         return resources;
     }
 
-    /**
-     * Validate if the graph-scan is supported in the Xray version
-     */
-    public async validateGraphSupported(): Promise<boolean> {
-        return await ConnectionUtils.testXrayVersionForScanGraph(this._connectionManager.createJfrogClient(), this._logManager);
-    }
-
     /**
      * Check if Contextual Analysis (Applicability) is supported for the user
      */
@@ -179,14 +167,9 @@ export class ScanManager implements ExtensionComponent {
     /**
      * Get all the entitlement status for each type of scan the manager offers
      */
-    public async getSupportedScans(): Promise<SupportedScans> {
-        let supportedScans: SupportedScans = {} as SupportedScans;
+    public async getSupportedScans(): Promise<EntitledScans> {
+        let supportedScans: EntitledScans = {} as EntitledScans;
         let requests: Promise<any>[] = [];
-        requests.push(
-            this.validateGraphSupported()
-                .then(res => (supportedScans.dependencies = res))
-                .catch(err => ScanUtils.onScanError(err, this._logManager, true))
-        );
         requests.push(
             this.isApplicabilitySupported()
                 .then(res => (supportedScans.applicability = res))
@@ -208,7 +191,7 @@ export class ScanManager implements ExtensionComponent {
                 .catch(err => ScanUtils.onScanError(err, this._logManager, true))
         );
         await Promise.all(requests);
-        this._supportedScans = supportedScans;
+        this._entitledScans = supportedScans;
         return supportedScans;
     }
 
@@ -250,60 +233,4 @@ export class ScanManager implements ExtensionComponent {
         );
         return await applicableRunner.scan(directory, checkCancel, cveToRun, skipFiles);
     }
-
-    /**
-     * Scan directory for 'Infrastructure As Code' (Iac) issues.
-     * @param module - the module that will be scanned
-     * @param checkCancel - check if should cancel
-     * @returns the Iac scan response
-     */
-    public async scanIac(module: Module, checkCancel: () => void): Promise<IacScanResponse | undefined> {
-        let iacRunner: IacRunner = new IacRunner(this._connectionManager, this.logManager);
-        if (!iacRunner.validateSupported()) {
-            this._logManager.logMessage('Iac runner could not find binary to run', 'WARN');
-            return undefined;
-        }
-        if (AppsConfigUtils.ShouldSkipScanner(module, ExcludeScanner.Iac)) {
-            this._logManager.debug('Skipping IaC scanning');
-            return undefined;
-        }
-        return await iacRunner.scan(module, checkCancel);
-    }
-    /**
-     * Scan directory for secrets issues.
-     * @param module - the module that will be scanned
-     * @param checkCancel - check if should cancel
-     * @returns the Secrets scan response
-     */
-    public async scanSecrets(module: Module, checkCancel: () => void): Promise<SecretsScanResponse | undefined> {
-        let secretsRunner: SecretsRunner = new SecretsRunner(this._connectionManager, this.logManager);
-        if (!secretsRunner.validateSupported()) {
-            this._logManager.logMessage('Secrets runner could not find binary to run', 'WARN');
-            return undefined;
-        }
-        if (AppsConfigUtils.ShouldSkipScanner(module, ExcludeScanner.Secrets)) {
-            this._logManager.debug('Skipping secrets scanning');
-            return undefined;
-        }
-        return await secretsRunner.scan(module, checkCancel);
-    }
-
-    /**
-     * Scan for SAST issues.
-     * @param module - the module that will be scanned
-     * @param requests - the SAST requests to run
-     * @returns the scan response
-     */
-    public async scanSast(module: Module, checkCancel: () => void): Promise<SastScanResponse | undefined> {
-        let sastRunner: SastRunner = new SastRunner(this._connectionManager, this._logManager);
-        if (!sastRunner.validateSupported()) {
-            this._logManager.logMessage('Sast runner could not find binary to run', 'WARN');
-            return undefined;
-        }
-        if (AppsConfigUtils.ShouldSkipScanner(module, ExcludeScanner.Sast)) {
-            this._logManager.debug('Skipping SAST scanning');
-            return undefined;
-        }
-        return sastRunner.scan(module, checkCancel);
-    }
 }

src/main/scanLogic/scanRunners/applicabilityScan.ts

@@ -1,10 +1,10 @@
-import { LogManager } from '../../log/logManager';
-import { BinaryRunner } from './binaryRunner';
-import { AnalyzeIssue, AnalyzeLocation, AnalyzerScanRun, ScanType, AnalyzeScanRequest, FileIssues } from './analyzerModels';
 import { ConnectionManager } from '../../connect/connectionManager';
+import { LogManager } from '../../log/logManager';
+import { Module } from '../../types/jfrogAppsConfig';
 import { Resource } from '../../utils/resource';
 import { ScanUtils } from '../../utils/scanUtils';
-import { PackageType } from '../../types/projectType';
+import { AnalyzeIssue, AnalyzeLocation, AnalyzeScanRequest, AnalyzerScanRun, FileIssues, ScanType } from './analyzerModels';
+import { JasScanner } from './binaryRunner';
 
 /**
  * The request that is sent to the binary to scan applicability
@@ -38,18 +38,14 @@ export interface CveApplicableDetails {
 /**
  * Describes a runner for the Applicability scan executable file.
  */
-export class ApplicabilityRunner extends BinaryRunner {
+export class ApplicabilityRunner extends JasScanner {
     constructor(
         connectionManager: ConnectionManager,
         logManager: LogManager,
         binary?: Resource,
         timeout: number = ScanUtils.ANALYZER_TIMEOUT_MILLISECS
     ) {
-        super(connectionManager, timeout, ScanType.ContextualAnalysis, logManager, binary);
-    }
-
-    public static supportedPackageTypes(): PackageType[] {
-        return [PackageType.Npm, PackageType.Yarn, PackageType.Python, PackageType.Maven];
+        super(connectionManager, timeout, ScanType.ContextualAnalysis, logManager, {} as Module, binary);
     }
 
     /** @override */