use of com.synopsys.integration.detect.lifecycle.run.data.ProductRunData in project synopsys-detect by blackducksoftware.
the class DetectBoot method boot.
public Optional<DetectBootResult> boot(String detectVersion, String detectBuildDate) throws IOException, IllegalAccessException {
if (detectArgumentState.isHelp() || detectArgumentState.isDeprecatedHelp() || detectArgumentState.isVerboseHelp()) {
HelpPrinter helpPrinter = new HelpPrinter();
helpPrinter.printAppropriateHelpMessage(DEFAULT_PRINT_STREAM, DetectProperties.allProperties().getProperties(), Arrays.asList(DetectGroup.values()), DetectGroup.BLACKDUCK_SERVER, detectArgumentState);
return Optional.of(DetectBootResult.exit(new PropertyConfiguration(propertySources)));
}
if (detectArgumentState.isHelpJsonDocument()) {
HelpJsonManager helpJsonManager = detectBootFactory.createHelpJsonManager();
helpJsonManager.createHelpJsonDocument(String.format("synopsys-detect-%s-help.json", detectVersion));
return Optional.of(DetectBootResult.exit(new PropertyConfiguration(propertySources)));
}
DEFAULT_PRINT_STREAM.println();
DEFAULT_PRINT_STREAM.println("Detect Version: " + detectVersion);
DEFAULT_PRINT_STREAM.println();
if (detectArgumentState.isInteractive()) {
InteractiveManager interactiveManager = detectBootFactory.createInteractiveManager(propertySources);
MapPropertySource interactivePropertySource = interactiveManager.executeInteractiveMode();
propertySources.add(0, interactivePropertySource);
}
PropertyConfiguration propertyConfiguration = new PropertyConfiguration(propertySources);
SortedMap<String, String> maskedRawPropertyValues = collectMaskedRawPropertyValues(propertyConfiguration);
publishCollectedPropertyValues(maskedRawPropertyValues);
logger.debug("Configuration processed completely.");
DetectConfigurationBootManager detectConfigurationBootManager = detectBootFactory.createDetectConfigurationBootManager(propertyConfiguration);
DeprecationResult deprecationResult = detectConfigurationBootManager.createDeprecationNotesAndPublishEvents(propertyConfiguration);
detectConfigurationBootManager.printConfiguration(maskedRawPropertyValues, deprecationResult.getAdditionalNotes());
Optional<DetectUserFriendlyException> possiblePropertyParseError = detectConfigurationBootManager.validateForPropertyParseErrors();
if (possiblePropertyParseError.isPresent()) {
return Optional.of(DetectBootResult.exception(possiblePropertyParseError.get(), propertyConfiguration));
}
logger.info("Detect build date: {}", detectBuildDate);
logger.debug("Initializing Detect.");
Configuration freemarkerConfiguration = detectBootFactory.createFreemarkerConfiguration();
PathResolver pathResolver = detectBootFactory.createPathResolver();
DetectPropertyConfiguration detectConfiguration = new DetectPropertyConfiguration(propertyConfiguration, new SimplePathResolver());
DetectConfigurationFactory detectConfigurationFactory = new DetectConfigurationFactory(detectConfiguration, gson);
DirectoryManager directoryManager = detectBootFactory.createDirectoryManager(detectConfigurationFactory);
InstalledToolLocator installedToolLocator = new InstalledToolLocator(directoryManager.getPermanentDirectory().toPath(), gson);
DiagnosticSystem diagnosticSystem = null;
DiagnosticDecision diagnosticDecision = DiagnosticDecision.decide(detectArgumentState, propertyConfiguration);
if (diagnosticDecision.shouldCreateDiagnosticSystem()) {
diagnosticSystem = detectBootFactory.createDiagnosticSystem(diagnosticDecision.isExtended(), propertyConfiguration, directoryManager, maskedRawPropertyValues);
}
logger.debug("Main boot completed. Deciding what Detect should do.");
if (detectArgumentState.isGenerateAirGapZip()) {
try {
AirGapType airGapType = new AirGapTypeDecider().decide(detectArgumentState);
AirGapCreator airGapCreator = detectBootFactory.createAirGapCreator(detectConfigurationFactory.createConnectionDetails(), detectConfigurationFactory.createDetectExecutableOptions(), freemarkerConfiguration, installedToolManager, installedToolLocator);
String gradleInspectorVersion = propertyConfiguration.getValueOrEmpty(DetectProperties.DETECT_GRADLE_INSPECTOR_VERSION).orElse(null);
File airGapZip = airGapCreator.createAirGapZip(airGapType, directoryManager.getRunHomeDirectory(), gradleInspectorVersion);
return Optional.of(DetectBootResult.exit(propertyConfiguration, airGapZip, directoryManager, diagnosticSystem));
} catch (DetectUserFriendlyException e) {
return Optional.of(DetectBootResult.exception(e, propertyConfiguration, directoryManager, diagnosticSystem));
}
}
logger.info("");
ProductRunData productRunData;
try {
ProductDecider productDecider = new ProductDecider();
BlackDuckDecision blackDuckDecision = productDecider.decideBlackDuck(detectConfigurationFactory.createBlackDuckConnectionDetails(), detectConfigurationFactory.createScanMode());
// TODO: Move to proper decision home. -jp
RunDecision runDecision = new RunDecision(detectConfigurationFactory.createDetectTarget() == DetectTargetType.IMAGE);
DetectToolFilter detectToolFilter = detectConfigurationFactory.createToolFilter(runDecision, blackDuckDecision);
oneRequiresTheOther(detectConfigurationFactory.createDetectTarget() == DetectTargetType.IMAGE, detectToolFilter.shouldInclude(DetectTool.DOCKER), "Detect target type is set to IMAGE, but the DOCKER tool was excluded.");
logger.debug("Decided what products will be run. Starting product boot.");
ProductBoot productBoot = detectBootFactory.createProductBoot(detectConfigurationFactory);
productRunData = productBoot.boot(blackDuckDecision, detectToolFilter);
} catch (DetectUserFriendlyException e) {
return Optional.of(DetectBootResult.exception(e, propertyConfiguration, directoryManager, diagnosticSystem));
}
if (productRunData == null) {
logger.info("No products to run, Detect is complete.");
return Optional.of(DetectBootResult.exit(propertyConfiguration, directoryManager, diagnosticSystem));
}
DetectableOptionFactory detectableOptionFactory;
try {
ProxyInfo detectableProxyInfo = detectConfigurationFactory.createBlackDuckProxyInfo();
detectableOptionFactory = new DetectableOptionFactory(detectConfiguration, diagnosticSystem, pathResolver, detectableProxyInfo);
oneRequiresTheOther(detectConfigurationFactory.createDetectTarget() == DetectTargetType.IMAGE, detectableOptionFactory.createDockerDetectableOptions().hasDockerImageOrTar(), "Detect target type is set to IMAGE, but no docker image was specified.");
} catch (DetectUserFriendlyException e) {
return Optional.of(DetectBootResult.exception(e, propertyConfiguration, directoryManager, diagnosticSystem));
}
BootSingletons bootSingletons = detectBootFactory.createRunDependencies(productRunData, propertyConfiguration, detectableOptionFactory, detectConfigurationFactory, directoryManager, freemarkerConfiguration, installedToolManager, installedToolLocator);
return Optional.of(DetectBootResult.run(bootSingletons, propertyConfiguration, productRunData, directoryManager, diagnosticSystem));
}
use of com.synopsys.integration.detect.lifecycle.run.data.ProductRunData in project synopsys-detect by blackducksoftware.
the class ProductBoot method boot.
public ProductRunData boot(BlackDuckDecision blackDuckDecision, DetectToolFilter detectToolFilter) throws DetectUserFriendlyException {
if (!blackDuckDecision.shouldRun()) {
throw new DetectUserFriendlyException("Your environment was not sufficiently configured to run Black Duck. See online help at: https://detect.synopsys.com/doc/", ExitCodeType.FAILURE_CONFIGURATION);
}
logger.debug("Detect product boot start.");
BlackDuckRunData blackDuckRunData = getBlackDuckRunData(blackDuckDecision, productBootFactory, blackDuckConnectivityChecker, productBootOptions, analyticsConfigurationService);
if (productBootOptions.isTestConnections()) {
logger.debug(String.format("%s is set to 'true' so Detect will not run.", DetectProperties.DETECT_TEST_CONNECTION.getName()));
return null;
}
logger.debug("Detect product boot completed.");
return new ProductRunData(blackDuckRunData, detectToolFilter);
}
use of com.synopsys.integration.detect.lifecycle.run.data.ProductRunData in project synopsys-detect by blackducksoftware.
the class DetectRun method run.
public void run(BootSingletons bootSingletons) {
Optional<OperationSystem> operationSystem = Optional.empty();
try {
SingletonFactory singletonFactory = new SingletonFactory(bootSingletons);
EventSingletons eventSingletons = singletonFactory.createEventSingletons();
UtilitySingletons utilitySingletons = singletonFactory.createUtilitySingletons(eventSingletons);
operationSystem = Optional.of(utilitySingletons.getOperationSystem());
// TODO: Remove run data from boot singletons
ProductRunData productRunData = bootSingletons.getProductRunData();
OperationFactory operationFactory = createOperationFactory(bootSingletons, utilitySingletons, eventSingletons);
StepHelper stepHelper = new StepHelper(utilitySingletons.getOperationSystem(), utilitySingletons.getOperationWrapper(), productRunData.getDetectToolFilter());
// Product independent tools
UniversalStepRunner stepRunner = new UniversalStepRunner(operationFactory, stepHelper);
UniversalToolsResult universalToolsResult = stepRunner.runUniversalTools();
// combine: processProjectInformation() -> ProjectResult (nameversion, bdio)
NameVersion nameVersion = stepRunner.determineProjectInformation(universalToolsResult);
operationFactory.publishProjectNameVersionChosen(nameVersion);
BdioResult bdio = stepRunner.generateBdio(universalToolsResult, nameVersion);
if (productRunData.shouldUseBlackDuckProduct()) {
BlackDuckRunData blackDuckRunData = productRunData.getBlackDuckRunData();
if (blackDuckRunData.isRapid() && blackDuckRunData.isOnline()) {
RapidModeStepRunner rapidModeSteps = new RapidModeStepRunner(operationFactory);
rapidModeSteps.runOnline(blackDuckRunData, nameVersion, bdio);
} else if (blackDuckRunData.isRapid()) {
logger.info("Rapid Scan is offline, nothing to do.");
} else if (blackDuckRunData.isOnline()) {
IntelligentModeStepRunner intelligentModeSteps = new IntelligentModeStepRunner(operationFactory, stepHelper);
intelligentModeSteps.runOnline(blackDuckRunData, bdio, nameVersion, productRunData.getDetectToolFilter(), universalToolsResult.getDockerTargetData());
} else {
IntelligentModeStepRunner intelligentModeSteps = new IntelligentModeStepRunner(operationFactory, stepHelper);
intelligentModeSteps.runOffline(nameVersion, universalToolsResult.getDockerTargetData());
}
}
} catch (Exception e) {
logger.error(ReportConstants.RUN_SEPARATOR);
logger.error("Detect run failed.");
exceptionUtility.logException(e);
logger.debug("An exception was thrown during the detect run.", e);
logger.error(ReportConstants.RUN_SEPARATOR);
exitCodeManager.requestExitCode(e);
checkForInterruptedException(e);
} finally {
operationSystem.ifPresent(OperationSystem::publishOperations);
}
}
use of com.synopsys.integration.detect.lifecycle.run.data.ProductRunData in project synopsys-detect by blackducksoftware.
the class ShutdownDecider method decideShutdown.
public ShutdownDecision decideShutdown(DetectBootResult detectBootResult) {
DiagnosticSystem diagnosticSystem = detectBootResult.getDiagnosticSystem().orElse(null);
PhoneHomeManager phoneHomeManager = detectBootResult.getProductRunData().filter(ProductRunData::shouldUseBlackDuckProduct).map(ProductRunData::getBlackDuckRunData).flatMap(BlackDuckRunData::getPhoneHomeManager).orElse(null);
CleanupDecision cleanupDecision = decideCleanup(detectBootResult.getDetectConfiguration().orElse(null), detectBootResult.getProductRunData().orElse(null), detectBootResult.getAirGapZip().orElse(null));
return new ShutdownDecision(phoneHomeManager, diagnosticSystem, cleanupDecision);
}
use of com.synopsys.integration.detect.lifecycle.run.data.ProductRunData in project synopsys-detect by blackducksoftware.
the class ShutdownDeciderTest method shouldPreserveBdioAndScanIfOffline.
@Test
public void shouldPreserveBdioAndScanIfOffline() {
ProductRunData productRunData = new ProductRunData(BlackDuckRunData.offline(), null);
CleanupDecision decision = new ShutdownDecider().decideCleanup(ConfigTestUtils.emptyConfig(), productRunData, null);
assertTrue(decision.shouldPreserveBdio());
assertTrue(decision.shouldPreserveScan());
}
Aggregations