public void start()

in modules/core/src/main/java/org/apache/tuscany/sca/core/assembly/CompositeActivatorImpl.java [581:691]
95 lines of code
20 McCabe index (conditional complexity)

    public void start(Component component) {
        if (logger.isLoggable(Level.FINE)) {
            logger.fine("Starting component: " + component.getURI());
        }
        RuntimeComponent runtimeComponent = ((RuntimeComponent)component);
        if (runtimeComponent.isStarted()) {
            return;
        }

        configureComponentContext(runtimeComponent);

        // TUSCANY-3466: We need to track all the providers that are started for the component
        final List<Object> providers = new ArrayList<Object>();
        try {

            for (ComponentReference reference : component.getReferences()) {
                if (logger.isLoggable(Level.FINE)) {
                    logger.fine("Starting component reference: " + component.getURI() + "#" + reference.getName());
                }
                RuntimeComponentReference runtimeRef = ((RuntimeComponentReference)reference);
                runtimeRef.setComponent(runtimeComponent);

                for (Endpoint endpoint : reference.getEndpoints()) {
                    final EndpointResolver endpointResolver = runtimeRef.getEndpointResolver(endpoint);
                    if (endpointResolver != null) {
                        // Allow endpoint resolvers to do any startup reference manipulation
                        AccessController.doPrivileged(new PrivilegedAction<Object>() {
                            public Object run() {
                                endpointResolver.start();
                                providers.add(endpointResolver);
                                return null;
                            }
                        });
                    }
                }

                for (Binding binding : reference.getBindings()) {
                    final ReferenceBindingProvider bindingProvider = runtimeRef.getBindingProvider(binding);
                    if (bindingProvider != null) {
                        // Allow bindings to add shutdown hooks. Requires RuntimePermission shutdownHooks in policy. 
                        AccessController.doPrivileged(new PrivilegedAction<Object>() {
                            public Object run() {
                                bindingProvider.start();
                                providers.add(bindingProvider);
                                return null;
                            }
                        });
                    }
                }
            }

            for (ComponentService service : component.getServices()) {
                if (logger.isLoggable(Level.FINE)) {
                    logger.fine("Starting component service: " + component.getURI() + "#" + service.getName());
                }
                RuntimeComponentService runtimeService = (RuntimeComponentService)service;
                for (Binding binding : service.getBindings()) {
                    final ServiceBindingProvider bindingProvider = runtimeService.getBindingProvider(binding);
                    if (bindingProvider != null) {
                        // bindingProvider.start();
                        // Allow bindings to add shutdown hooks. Requires RuntimePermission shutdownHooks in policy. 
                        AccessController.doPrivileged(new PrivilegedAction<Object>() {
                            public Object run() {
                                bindingProvider.start();
                                providers.add(bindingProvider);
                                return null;
                            }
                        });
                    }
                }
            }

            Implementation implementation = component.getImplementation();
            if (implementation instanceof Composite) {
                try {
                    start((Composite)implementation);
                } catch (Throwable e) {
                    // Stop the started components within the composite
                    try {
                        stop((Composite)implementation);
                    } catch (Throwable e1) {
                        error("StopException", implementation, e1);
                    }
                    rethrow(e);
                }
            } else {
                ImplementationProvider implementationProvider = runtimeComponent.getImplementationProvider();
                if (implementationProvider != null) {
                    implementationProvider.start();
                    providers.add(implementationProvider);
                }
            }

            if (component instanceof ScopedRuntimeComponent) {
                ScopedRuntimeComponent scopedRuntimeComponent = (ScopedRuntimeComponent)component;
                ScopeContainer<?> scopeContainer = scopedRuntimeComponent.getScopeContainer();
                if (scopeContainer != null) {
                    scopeContainer.start();
                    providers.add(scopeContainer);
                }
            }
        } catch (Throwable e) {
            // Stop all the providers that are already started so far
            stopProviders(providers);
            rethrow(e);
        } finally {
            providers.clear();
        }

        runtimeComponent.setStarted(true);
    }