diff -r cfc3d11884ad -r 27a0fdd7bca7 src/main/java/de/uapcore/lightpit/ModuleManager.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/de/uapcore/lightpit/ModuleManager.java Sat May 09 14:26:31 2020 +0200 @@ -0,0 +1,231 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2018 Mike Becker. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ +package de.uapcore.lightpit; + +import de.uapcore.lightpit.entities.CoreDAOFactory; +import de.uapcore.lightpit.entities.Module; +import de.uapcore.lightpit.entities.ModuleDao; +import java.sql.Connection; +import java.sql.SQLException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.stream.Collectors; +import javax.servlet.Registration; +import javax.servlet.ServletContext; +import javax.servlet.ServletContextEvent; +import javax.servlet.ServletContextListener; +import javax.servlet.annotation.WebListener; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Scans registered servlets for LightPIT modules. + */ +@WebListener +public final class ModuleManager implements ServletContextListener { + + private static final Logger LOG = LoggerFactory.getLogger(ModuleManager.class); + + /** + * The attribute name in the servlet context under which an instance of this class can be found. + */ + public static final String SC_ATTR_NAME = ModuleManager.class.getName(); + private ServletContext sc; + + /** + * Maps class names to module information. + */ + private final Map registeredModules = new HashMap<>(); + + /** + * This flag is true, when synchronization is needed. + */ + private final AtomicBoolean dirty = new AtomicBoolean(true); + + @Override + public void contextInitialized(ServletContextEvent sce) { + sc = sce.getServletContext(); + reloadAll(); + sc.setAttribute(SC_ATTR_NAME, this); + LOG.info("Module manager injected into ServletContext."); + } + + @Override + public void contextDestroyed(ServletContextEvent sce) { + unloadAll(); + } + + private Optional getModuleInfo(Registration reg) { + try { + final Class scclass = Class.forName(reg.getClassName()); + + final boolean lpservlet = AbstractLightPITServlet.class.isAssignableFrom(scclass); + final boolean lpmodule = scclass.isAnnotationPresent(LightPITModule.class); + + if (lpservlet && !lpmodule) { + LOG.warn( + "{} is a LightPIT Servlet but is missing the module annotation.", + reg.getClassName() + ); + } else if (!lpservlet && lpmodule) { + LOG.warn( + "{} is annotated as a LightPIT Module but does not extend {}.", + reg.getClassName(), + AbstractLightPITServlet.class.getSimpleName() + ); + } + + if (lpservlet && lpmodule) { + final Class clazz = scclass; + final LightPITModule moduleInfo = clazz.getAnnotation(LightPITModule.class); + return Optional.of(moduleInfo); + } else { + return Optional.empty(); + } + } catch (ClassNotFoundException ex) { + LOG.error( + "Servlet registration refers to class {} which cannot be found by the class loader (Reason: {})", + reg.getClassName(), + ex.getMessage() + ); + return Optional.empty(); + } + } + + private void handleServletRegistration(String name, Registration reg) { + final Optional moduleInfo = getModuleInfo(reg); + if (moduleInfo.isPresent()) { + registeredModules.put(reg.getClassName(), moduleInfo.get()); + LOG.info("Module detected: {}", name); + } else { + LOG.debug("Servlet {} is no module, skipping.", name); + } + } + + /** + * Scans for modules and reloads them all. + */ + public void reloadAll() { + registeredModules.clear(); + sc.getServletRegistrations().forEach(this::handleServletRegistration); + + // TODO: implement dependency resolver + + dirty.set(true); + LOG.info("Modules loaded."); + } + + /** + * Synchronizes module information with the database. + * + * This must be called from the {@link AbstractLightPITServlet}. + * Admittedly the call will perform the synchronization once after reload + * and be a no-op, afterwards. + * However, we since the DatabaseFacade might be loaded after the module + * manager, we must defer the synchronization to the first request + * handled by the Servlet. + * + * @param db interface to the database + */ + public void syncWithDatabase(DatabaseFacade db) { + if (dirty.compareAndSet(true, false)) { + if (db.getDataSource().isPresent()) { + try (Connection conn = db.getDataSource().get().getConnection()) { + final ModuleDao moduleDao = CoreDAOFactory.getModuleDao(db.getSQLDialect()); + moduleDao.syncRegisteredModuleClasses(conn, registeredModules.entrySet()); + } catch (SQLException ex) { + LOG.error("Unexpected SQL Exception", ex); + } + } else { + LOG.error("No datasource present. Cannot sync module information with database."); + } + } else { + LOG.trace("Module information clean - no synchronization required."); + } + } + + /** + * Unloads all found modules. + */ + public void unloadAll() { + registeredModules.clear(); + LOG.info("All modules unloaded."); + } + + /** + * Returns the main menu. + * + * @param db the interface to the database + * @return a list of menus belonging to the main menu + */ + public List getMainMenu(DatabaseFacade db) { + // TODO: user specific menu + + if (db.getDataSource().isPresent()) { + try (Connection conn = db.getDataSource().get().getConnection()) { + final ModuleDao dao = CoreDAOFactory.getModuleDao(db.getSQLDialect()); + final List modules = dao.listAll(conn); + + final List menu = modules + .stream() + .filter((mod) -> mod.isVisible()) + .collect(Collectors.mapping( + (mod) -> new Menu( + mod.getClassname(), + new ResourceKey( + registeredModules.get(mod.getClassname()).bundleBaseName(), + registeredModules.get(mod.getClassname()).menuKey()), + registeredModules.get(mod.getClassname()).modulePath()), + Collectors.toList()) + ); + return menu; + } catch (SQLException ex) { + LOG.error("Unexpected SQLException when loading the main menu", ex); + return Collections.emptyList(); + } + } else { + return Collections.emptyList(); + } + } + + /** + * Returns an unmodifiable map of all registered modules. + * + * The key is the classname of the module. + * + * @return the map of registered modules + */ + public Map getRegisteredModules() { + return Collections.unmodifiableMap(registeredModules); + } +}