Examples with ManagedBeanFactory com.canoo.platform.server.spi.components.ManagedBeanFactory used on opensource projects

Example 1 with ManagedBeanFactory

use of com.canoo.platform.server.spi.components.ManagedBeanFactory in project dolphin-platform by canoo.

the class PlatformBootstrap method getBeanFactory.

private ManagedBeanFactory getBeanFactory(final ServletContext servletContext) {
    final ServiceLoader<ManagedBeanFactory> serviceLoader = ServiceLoader.load(ManagedBeanFactory.class);
    final Iterator<ManagedBeanFactory> serviceIterator = serviceLoader.iterator();
    if (serviceIterator.hasNext()) {
        final ManagedBeanFactory factory = serviceIterator.next();
        if (serviceIterator.hasNext()) {
            throw new IllegalStateException("More than 1 " + ManagedBeanFactory.class + " found!");
        }
        LOG.debug("Container Manager of type {} is used", factory.getClass().getSimpleName());
        factory.init(servletContext);
        return factory;
    } else {
        throw new IllegalStateException("No " + ManagedBeanFactory.class + " found!");
    }
}

Example 2 with ManagedBeanFactory

use of com.canoo.platform.server.spi.components.ManagedBeanFactory in project dolphin-platform by canoo.

the class RemotingModule method initialize.

@Override
public void initialize(ServerCoreComponents coreComponents) throws ModuleInitializationException {
    LOG.info("Starting Dolphin Platform");
    try {
        final ServletContext servletContext = coreComponents.getInstance(ServletContext.class);
        final ClasspathScanner classpathScanner = coreComponents.getInstance(ClasspathScanner.class);
        final ManagedBeanFactory beanFactory = coreComponents.getInstance(ManagedBeanFactory.class);
        final RemotingConfiguration configuration = new RemotingConfiguration(coreComponents.getConfiguration());
        final ClientSessionProvider sessionProvider = coreComponents.getInstance(ClientSessionProvider.class);
        final DolphinContextFactory dolphinContextFactory = new DefaultDolphinContextFactory(configuration, sessionProvider, beanFactory, classpathScanner);
        final DolphinContextCommunicationHandler communicationHandler = new DolphinContextCommunicationHandler(sessionProvider, dolphinContextFactory);
        final DolphinContextProvider contextProvider = new DolphinContextProvider() {

            @Override
            public DolphinContext getContext(final ClientSession clientSession) {
                return communicationHandler.getContext(clientSession);
            }

            @Override
            public DolphinContext getContextById(String clientSessionId) {
                return communicationHandler.getContextById(clientSessionId);
            }

            @Override
            public DolphinContext getCurrentDolphinContext() {
                return communicationHandler.getCurrentDolphinContext();
            }
        };
        coreComponents.provideInstance(DolphinContextProvider.class, contextProvider);
        final ClientSessionLifecycleHandler lifecycleHandler = coreComponents.getInstance(ClientSessionLifecycleHandler.class);
        servletContext.addServlet(DOLPHIN_SERVLET_NAME, new DolphinPlatformServlet(communicationHandler)).addMapping(configuration.getDolphinPlatformServletMapping());
        servletContext.addServlet(INTERRUPT_SERVLET_NAME, new InterruptServlet(contextProvider)).addMapping(configuration.getDolphinPlatformInterruptServletMapping());
        LOG.debug("Dolphin Platform initialized under context \"" + servletContext.getContextPath() + "\"");
        LOG.debug("Dolphin Platform endpoint defined as " + configuration.getDolphinPlatformServletMapping());
        Iterator<EventBusProvider> iterator = ServiceLoader.load(EventBusProvider.class).iterator();
        boolean providerFound = false;
        boolean flag = false;
        while (iterator.hasNext()) {
            EventBusProvider provider = iterator.next();
            if (configuration.getEventbusType().equals(provider.getType())) {
                if (providerFound) {
                    throw new IllegalStateException("More than 1 event bus provider found");
                }
                LOG.debug("Using event bus of type {} with provider class {}", provider.getType(), provider.getClass());
                providerFound = true;
                RemotingEventBus eventBus = provider.create(configuration);
                if (eventBus instanceof AbstractEventBus) {
                    ((AbstractEventBus) eventBus).init(contextProvider, lifecycleHandler);
                }
                coreComponents.provideInstance(RemotingEventBus.class, eventBus);
                flag = true;
            }
        }
        if (!flag) {
            throw new ModuleInitializationException("Configured event bus is not on the classpath.");
        }
    } catch (ControllerValidationException cve) {
        throw new ModuleInitializationException("Can not start Remote Presentation Model support based on bad controller definition", cve);
    }
}

Example 3 with ManagedBeanFactory

use of com.canoo.platform.server.spi.components.ManagedBeanFactory in project dolphin-platform by canoo.

the class PlatformBootstrap method init.

public void init(final ServletContext servletContext, final ServerConfiguration configuration) {
    Assert.requireNonNull(servletContext, "servletContext");
    Assert.requireNonNull(configuration, "configuration");
    ContextManagerImpl.getInstance().addGlobalContext(APPLICATION_CONTEXT, configuration.getProperty(APPLICATION_NAME_PROPERTY));
    if (configuration.getBooleanProperty(PLATFORM_ACTIVE)) {
        PlatformLogo.printLogo();
        try {
            LOG.info("Will boot Dolphin Plaform now");
            servletContext.setAttribute(CONFIGURATION_ATTRIBUTE_NAME, configuration);
            configuration.log();
            MBeanRegistry.getInstance().setMbeanSupport(configuration.getBooleanProperty(MBEAN_REGISTRATION));
            // TODO: We need to provide a container specific thread factory that contains managed threads
            // See https://github.com/canoo/dolphin-platform/issues/498
            final PlatformThreadFactory threadFactory = new SimpleDolphinPlatformThreadFactory();
            final ManagedBeanFactory beanFactory = getBeanFactory(servletContext);
            final DefaultClasspathScanner classpathScanner = new DefaultClasspathScanner(configuration.getListProperty(ROOT_PACKAGE_FOR_CLASSPATH_SCAN));
            serverCoreComponents = new ServerCoreComponentsImpl(servletContext, configuration, threadFactory, classpathScanner, beanFactory);
            final Set<Class<?>> moduleClasses = classpathScanner.getTypesAnnotatedWith(ModuleDefinition.class);
            final Map<String, ServerModule> modules = new HashMap<>();
            for (final Class<?> moduleClass : moduleClasses) {
                if (!ServerModule.class.isAssignableFrom(moduleClass)) {
                    throw new DolphinRuntimeException("Class " + moduleClass + " is annoated with " + ModuleDefinition.class.getSimpleName() + " but do not implement " + ServerModule.class.getSimpleName());
                }
                ModuleDefinition moduleDefinition = moduleClass.getAnnotation(ModuleDefinition.class);
                ServerModule instance = (ServerModule) moduleClass.newInstance();
                modules.put(instance.getName(), instance);
            }
            LOG.info("Found {} Dolphin Plaform modules", modules.size());
            if (LOG.isTraceEnabled()) {
                for (final String moduleName : modules.keySet()) {
                    LOG.trace("Found Dolphin Plaform module {}", moduleName);
                }
            }
            for (final Map.Entry<String, ServerModule> moduleEntry : modules.entrySet()) {
                LOG.debug("Will initialize Dolphin Plaform module {}", moduleEntry.getKey());
                final ServerModule module = moduleEntry.getValue();
                if (module.shouldBoot(serverCoreComponents.getConfiguration())) {
                    final List<String> neededModules = module.getModuleDependencies();
                    for (final String neededModule : neededModules) {
                        if (!modules.containsKey(neededModule)) {
                            throw new ModuleInitializationException("Module " + moduleEntry.getKey() + " depends on missing module " + neededModule);
                        }
                    }
                    module.initialize(serverCoreComponents);
                }
            }
            LOG.info("Dolphin Plaform booted");
        } catch (Exception e) {
            throw new RuntimeException("Can not boot Dolphin Platform", e);
        }
    } else {
        LOG.info("Dolphin Plaform is deactivated");
    }
}

Example 4 with ManagedBeanFactory

use of com.canoo.platform.server.spi.components.ManagedBeanFactory in project dolphin-platform by canoo.

the class ClientSessionModule method initialize.

@Override
public void initialize(final ServerCoreComponents coreComponents) throws ModuleInitializationException {
    Assert.requireNonNull(coreComponents, "coreComponents");
    final ServletContext servletContext = coreComponents.getInstance(ServletContext.class);
    final PlatformConfiguration configuration = coreComponents.getConfiguration();
    final ClasspathScanner classpathScanner = coreComponents.getInstance(ClasspathScanner.class);
    final ManagedBeanFactory beanFactory = coreComponents.getInstance(ManagedBeanFactory.class);
    final ClientSessionLifecycleHandlerImpl lifecycleHandler = new ClientSessionLifecycleHandlerImpl();
    coreComponents.provideInstance(ClientSessionLifecycleHandler.class, lifecycleHandler);
    coreComponents.provideInstance(ClientSessionProvider.class, new ClientSessionProvider() {

        @Override
        public ClientSession getCurrentClientSession() {
            return lifecycleHandler.getCurrentDolphinSession();
        }
    });
    final ClientSessionManager clientSessionManager = new ClientSessionManager(configuration, lifecycleHandler);
    final List<String> endpointList = configuration.getListProperty(ID_FILTER_URL_MAPPINGS, ID_FILTER_URL_MAPPINGS_DEFAULT_VALUE);
    final String[] endpoints = endpointList.toArray(new String[endpointList.size()]);
    final ClientSessionFilter filter = new ClientSessionFilter(clientSessionManager);
    final FilterRegistration.Dynamic createdFilter = servletContext.addFilter(DOLPHIN_CLIENT_ID_FILTER_NAME, filter);
    createdFilter.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, endpoints);
    final HttpSessionCleanerListener sessionCleaner = new HttpSessionCleanerListener(clientSessionManager);
    servletContext.addListener(sessionCleaner);
    final Set<Class<?>> listeners = classpathScanner.getTypesAnnotatedWith(ServerListener.class);
    for (final Class<?> listenerClass : listeners) {
        if (ClientSessionListener.class.isAssignableFrom(listenerClass)) {
            final ClientSessionListener listener = (ClientSessionListener) beanFactory.createDependentInstance(listenerClass);
            lifecycleHandler.addSessionDestroyedListener(s -> listener.sessionDestroyed(s));
            lifecycleHandler.addSessionCreatedListener(s -> listener.sessionCreated(s));
        }
    }
    final ClientSessionMutextHolder mutextHolder = new ClientSessionMutextHolder();
    lifecycleHandler.addSessionDestroyedListener(s -> mutextHolder.sessionDestroyed(s));
    lifecycleHandler.addSessionCreatedListener(s -> mutextHolder.sessionCreated(s));
}