public Deployer start()

in core/container/src/main/java/org/wildfly/swarm/container/runtime/RuntimeServer.java [142:289]
94 lines of code
12 McCabe index (conditional complexity)

    public Deployer start(boolean eagerOpen) throws Exception {

        UUID uuid = UUIDFactory.getUUID();
        System.setProperty("jboss.server.management.uuid", uuid.toString());

        File configurationFile;
        try {
            configurationFile = TempFileManager.INSTANCE.newTempFile("thorntail-config-", ".xml");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        this.networkConfigurer.configure();

        List<ModelNode> bootstrapOperations = new ArrayList<>();
        BootstrapConfiguration bootstrapConfiguration = () -> bootstrapOperations;

        this.container = new SelfContainedContainer(new Bootstrap.ConfigurationPersisterFactory() {
            @Override
            public ExtensibleConfigurationPersister createConfigurationPersister(ServerEnvironment serverEnvironment, ExecutorService executorService) {
                return new BootstrapPersister(bootstrapConfiguration, configurationFile);
            }
        });

        Set<String> ignoredCustomizers = ignoredCustomizers();

        try (AutoCloseable handle = Performance.time("pre-customizers")) {
            for (Customizer each : this.preCustomizers) {
                if (ignoredCustomizers.contains(each.getClass().getName())
                        // to account for Weld proxies
                        || ignoredCustomizers.contains(each.getClass().getSuperclass().getName())) {
                    continue;
                }

                SwarmMessages.MESSAGES.callingPreCustomizer(each);
                each.customize();
            }
        }

        try (AutoCloseable handle = Performance.time("post-customizers")) {
            for (Customizer each : this.postCustomizers) {
                if (ignoredCustomizers.contains(each.getClass().getName())
                        // to account for Weld proxies
                        || ignoredCustomizers.contains(each.getClass().getSuperclass().getName())) {
                    continue;
                }

                SwarmMessages.MESSAGES.callingPostCustomizer(each);
                each.customize();
            }
        }

        this.networkConfigurer.configure();

        /*
        this.archivePreparers.forEach(e -> {
            // Log it to prevent dead-code elimination.
            //
            // This is purely to ensure @Configurables are scanned
            // prior to logging the configurables.
            SwarmMessages.MESSAGES.registeredArchivePreparer(e.toString());
        });
        */

        try (AutoCloseable handle = Performance.time("configurable-manager rescan")) {
            this.configurableManager.rescan();
            this.configurableManager.log();
        }

        try (AutoCloseable handle = Performance.time("marshall DMR")) {
            this.dmrMarshaller.marshal(bootstrapOperations);
        }

        SwarmMessages.MESSAGES.wildflyBootstrap(bootstrapOperations.toString());

        Thread.currentThread().setContextClassLoader(RuntimeServer.class.getClassLoader());

        List<ServiceActivator> activators = new ArrayList<>();

        StreamSupport.stream(serviceActivators.spliterator(), false)
                .filter(Objects::nonNull)
                .forEach(activators::add);

        activators.add(new ContentRepositoryServiceActivator(this.contentRepository));

        try (AutoCloseable wildflyStart = Performance.time("WildFly start")) {
            ServiceContainer serviceContainer = null;
            try (AutoCloseable startWildflyItself = Performance.time("Starting WildFly itself")) {
                //serviceContainer = this.container.start(bootstrapOperations, this.contentProvider, activators);
                serviceContainer = this.container.start(bootstrapOperations, activators);
                this.containerStarted = true;
            }
            try (AutoCloseable checkFailedServices = Performance.time("Checking for failed services")) {
                for (ServiceName serviceName : serviceContainer.getServiceNames()) {
                    ServiceController<?> serviceController = serviceContainer.getService(serviceName);
                    /*
                    if (!serviceController.getUnavailableDependencies().isEmpty()) {
                        System.err.println("Service missing dependencies: " + serviceController.getName());
                        for (ServiceName name : serviceController.getUnavailableDependencies()) {
                            System.err.println("  - " + name);
                        }
                    }
                    */
                    StartException exception = serviceController.getStartException();
                    if (exception != null) {
                        throw exception;
                    }
                }
            }

            /*
            for (ServiceName serviceName : serviceContainer.getServiceNames()) {
                System.err.println(" === " + serviceName);
            }
            */

            try (AutoCloseable creatingControllerClient = Performance.time("Creating controller client")) {
                Executor executor = Executors.newSingleThreadExecutor();
                ModelControllerClientFactory clientFactory = (ModelControllerClientFactory) serviceContainer.getService(
                        ServerService.JBOSS_SERVER_CLIENT_FACTORY).getValue();
                this.client = clientFactory.createSuperUserClient(executor);
            }

            RuntimeDeployer deployer = this.deployer.get();

            try (AutoCloseable installDeployer = Performance.time("Installing deployer")) {
                serviceContainer.addService(ServiceName.of("thorntail", "deployer"), new ValueService<>(new ImmediateValue<>(deployer))).install();
            }

            try (AutoCloseable configUserSpaceExt = Performance.time("Configure user-space extensions")) {
                configureUserSpaceExtensions();
            }

            try (AutoCloseable deployments = Performance.time("Implicit Deployments")) {
                for (Archive each : this.implicitDeployments) {
                    if (each != null) {
                        deployer.deploy(each);
                    }
                }
            }

            this.artifactDeployer.deploy();

            deployer.implicitDeploymentsComplete();

            return deployer;
        }
    }