public void run()

in src/main/java/org/apache/sling/feature/cpconverter/cli/ContentPackage2FeatureModelConverterLauncher.java [154:320]


    public void run() {
        if (quiet) {
            System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "error");
        } else if (debug) {
            System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "debug");
        } else {
            System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "info");
        }
        System.setProperty("org.slf4j.simpleLogger.showThreadName", "false");
        System.setProperty("org.slf4j.simpleLogger.levelInBrackets", "true");
        System.setProperty("org.slf4j.simpleLogger.showLogName", "false");

        String appName = getClass().getAnnotation(Command.class).description()[0];
        final Logger logger = LoggerFactory.getLogger(appName);

        //output the current tmp directory
        logger.debug("Using tmp directory {}", System.getProperty("java.io.tmpdir"));

        final long start = System.currentTimeMillis();

        if (printVersion) {
            printVersion(logger);
        }

        logger.info(appName);
        logger.info("");

        boolean exitWithError = false;

        try {
            try {
                AclManager aclManager = new DefaultAclManager(enforcePrincipalBasedSupportedPath, systemUserRelPath, alwaysForceSystemUserPath);

                DefaultFeaturesManager featuresManager = new DefaultFeaturesManager(mergeConfigurations,
                                                                bundlesStartOrder,
                                                                featureModelsOutputDirectory,
                                                                artifactIdOverride,
                                                                fmPrefix,
                                                                properties,
                                                                aclManager);

                featuresManager.setEnforceServiceMappingByPrincipal(enforceServiceMappingByPrincipal);

                if (seedFeature != null) {
                    try(Reader reader = new InputStreamReader(new URL(seedFeature).openStream(), "UTF-8")) {
                        Feature seed = FeatureJSONReader.read(reader, seedFeature);
                        System.out.println(seed);
                        featuresManager.addSeed(seed);
                    }
                }

                if (apiRegions != null)
                    featuresManager.setAPIRegions(apiRegions);

                if (exportsToRegion != null)
                    featuresManager.setExportToAPIRegion(exportsToRegion);

                Map<String, String> entryHandlerConfigsMap = new HashMap<>();
                if (entryHandlerConfigs != null) {
                    for (String config : entryHandlerConfigs) {
                        int idx = config.indexOf(':');
                        if (idx != -1) {
                            entryHandlerConfigsMap.put(config.substring(0, idx), config.substring(idx + 1));
                        }
                    }
                }

                try (ContentPackage2FeatureModelConverter converter = new ContentPackage2FeatureModelConverter(strictValidation, slingInitialContentPolicy, disablePackageTypeRecalculation, runModePolicy)) {
                    BundleSlingInitialContentExtractor bundleSlingInitialContentExtractor = new BundleSlingInitialContentExtractor();
                    converter.setFeaturesManager(featuresManager)
                             .setBundlesDeployer(new LocalMavenRepositoryArtifactsDeployer(artifactsOutputDirectory))
                             .setBundleSlingInitialContentExtractor(bundleSlingInitialContentExtractor)
                             .setEntryHandlersManager(new DefaultEntryHandlersManager(entryHandlerConfigsMap, !disableInstallerPolicy, slingInitialContentPolicy, bundleSlingInitialContentExtractor, systemUserRelPath))
                             .setAclManager(aclManager)
                             .setIndexManager(new DefaultIndexManager())
                             .setEmitter(DefaultPackagesEventsEmitter.open(featureModelsOutputDirectory))
                             .setFailOnMixedPackages(failOnMixedPackages)
                             .setContentTypePackagePolicy(contentTypePackagePolicy);
                    if (unreferencedArtifactsOutputDirectory != null) {
                        converter.setUnreferencedArtifactsDeployer(new LocalMavenRepositoryArtifactsDeployer(unreferencedArtifactsOutputDirectory));
                    } else if (contentTypePackagePolicy == ContentPackage2FeatureModelConverter.PackagePolicy.PUT_IN_DEDICATED_FOLDER) {
                        throw new IllegalStateException("Argument '--content-type-package-policy PUT_IN_DEDICATED_FOLDER' requires argument '--unreferenced-artifacts-output-directory' as well!");
                    }
                    if (filteringPatterns != null && filteringPatterns.length > 0) {
                        RegexBasedResourceFilter filter = new RegexBasedResourceFilter();

                        for (String filteringPattern : filteringPatterns) {
                            filter.addFilteringPattern(filteringPattern);
                        }

                        converter.setResourceFilter(filter);
                    }
                    converter.convert(contentPackages);
                }

                logger.info( "+-----------------------------------------------------+" );
                logger.info("{} SUCCESS", appName);
            } catch (ConverterException ce) {
                logger.info( "+-----------------------------------------------------+" );
                logger.info("{} FAILURE", appName);
                logger.info( "+-----------------------------------------------------+" );
                logger.error("Unable to convert content-package {}: {}", contentPackages, ce.getMessage());
                logger.info( "+-----------------------------------------------------+" );
                exitWithError = true;
            } catch (Throwable t) {
                logger.info( "+-----------------------------------------------------+" );
                logger.info("{} FAILURE", appName);
                logger.info( "+-----------------------------------------------------+" );

                if (debug) {
                    logger.error("Unable to convert content-package {}:", contentPackages, t);
                } else {
                    logger.error("Unable to convert content-package {}: {}", contentPackages, t.getMessage());
                }

                logger.info( "+-----------------------------------------------------+" );

                exitWithError = true;
            }
        } finally {
            // format the uptime string
            Formatter uptimeFormatter = new Formatter();
            uptimeFormatter.format("Total time:");
    
            long uptime = System.currentTimeMillis() - start;
            if (uptime < 1000) {
                uptimeFormatter.format(" %s millisecond%s", uptime, (uptime > 1 ? "s" : ""));
            } else {
                long uptimeInSeconds = (uptime) / 1000;
                final long hours = uptimeInSeconds / 3600;
    
                if (hours > 0) {
                    uptimeFormatter.format(" %s hour%s", hours, (hours > 1 ? "s" : ""));
                }
    
                uptimeInSeconds = uptimeInSeconds - (hours * 3600);
                final long minutes = uptimeInSeconds / 60;
    
                if (minutes > 0) {
                    uptimeFormatter.format(" %s minute%s", minutes, (minutes > 1 ? "s" : ""));
                }
    
                uptimeInSeconds = uptimeInSeconds - (minutes * 60);
    
                if (uptimeInSeconds > 0) {
                    uptimeFormatter.format(" %s second%s", uptimeInSeconds, (uptimeInSeconds > 1 ? "s" : ""));
                }
            }
            logger.info(uptimeFormatter.toString());
    
            uptimeFormatter.close();
    
            logger.info("Finished at: {}", new Date());
    
            final Runtime runtime = Runtime.getRuntime();
            final int megaUnit = 1024 * 1024;
    
            logger.info("Final Memory: {}M/{}M",
                        (runtime.totalMemory() - runtime.freeMemory()) / megaUnit,
                        runtime.totalMemory() / megaUnit);
            logger.info("+-----------------------------------------------------+");
        }

        if ( exitWithError ) {
            System.exit(1);
        }
    }