Java tutorial
/* * Copyright 2012-2013, CMM, University of Queensland. * * This file is part of Paul. * * Paul is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Paul is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Paul. If not, see <http://www.gnu.org/licenses/>. */ package au.edu.uq.cmm.paul; import java.io.IOException; import java.util.Objects; import javax.persistence.EntityManagerFactory; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.context.Lifecycle; import au.edu.uq.cmm.aclslib.message.AclsClient; import au.edu.uq.cmm.aclslib.proxy.AclsHelper; import au.edu.uq.cmm.aclslib.service.Service; import au.edu.uq.cmm.aclslib.service.ServiceBase; import au.edu.uq.cmm.aclslib.service.ServiceException; import au.edu.uq.cmm.eccles.EcclesUserDetailsManager; import au.edu.uq.cmm.eccles.ProxyConfiguration; import au.edu.uq.cmm.eccles.StaticEcclesProxyConfiguration; import au.edu.uq.cmm.eccles.UserDetailsManager; import au.edu.uq.cmm.paul.queue.AtomFeed; import au.edu.uq.cmm.paul.queue.QueueExpirer; import au.edu.uq.cmm.paul.queue.QueueManager; import au.edu.uq.cmm.paul.servlet.ConfigurationManager; import au.edu.uq.cmm.paul.servlet.Status; import au.edu.uq.cmm.paul.status.FacilityStatusManager; import au.edu.uq.cmm.paul.watcher.FileWatcher; import au.edu.uq.cmm.paul.watcher.SambaUncPathnameMapper; import au.edu.uq.cmm.paul.watcher.UncPathnameMapper; /** * This class represents the Paul application as a whole, with getters that * allow the different components to access each other. The class also * implements the ACSLib "Service" API. * * @author scrawley */ public class Paul extends ServiceBase implements Lifecycle { // FIXME - need to do something to hook this class into the servlet lifecycle // so that it gets told when the servlet is being shutdown. private static final Logger LOG = LoggerFactory.getLogger(Paul.class); private final FacilityStatusManager statusManager; private final UncPathnameMapper uncNameMapper; private final EntityManagerFactory entityManagerFactory; private final QueueManager queueManager; private final QueueExpirer queueExpirer; private final FileWatcher fileWatcher; private final UserDetailsManager userDetailsManager; private final ConfigurationManager configManager; private final PaulFacilityMapper facilityMapper; private final AclsHelper aclsHelper; private final AtomFeed atomFeed; private final PaulControl control; public Paul(StaticPaulConfiguration staticConfig, StaticEcclesProxyConfiguration staticProxyConfig, StaticPaulFacilities staticFacilities, EntityManagerFactory entityManagerFactory) throws IOException { this(staticConfig, staticProxyConfig, staticFacilities, entityManagerFactory, new SambaUncPathnameMapper()); } public Paul(StaticPaulConfiguration staticConfig, StaticEcclesProxyConfiguration staticProxyConfig, StaticPaulFacilities staticFacilities, EntityManagerFactory entityManagerFactory, UncPathnameMapper uncNameMapper) throws IOException { this.entityManagerFactory = entityManagerFactory; this.uncNameMapper = uncNameMapper; this.configManager = new ConfigurationManager(this, entityManagerFactory, staticConfig, staticProxyConfig, staticFacilities); this.facilityMapper = new PaulFacilityMapper(entityManagerFactory); ProxyConfiguration proxyConfig = configManager.getActiveProxyConfig(); this.aclsHelper = new AclsHelper(proxyConfig.getProxyHost(), proxyConfig.getProxyPort(), /* * Use double the default timeout, because the proxy potentially * has to timeout the downstream ACLS server. (Hack) */ AclsClient.ACLS_REQUEST_TIMEOUT * 2, false); this.userDetailsManager = new EcclesUserDetailsManager(entityManagerFactory, proxyConfig.getFallbackMode()); this.statusManager = new FacilityStatusManager(this); this.fileWatcher = new FileWatcher(this); this.queueManager = new QueueManager(this); this.queueExpirer = new QueueExpirer(this); this.control = PaulControl.load(entityManagerFactory); this.atomFeed = new AtomFeed(control); setupDefaultUncaughtExceptionHandler(); } private void setupDefaultUncaughtExceptionHandler() { if (Thread.getDefaultUncaughtExceptionHandler() == null) { LOG.info("Setting the uncaught exception handler"); } else { LOG.info("Changing the uncaught exception handler"); } Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() { @Override public void uncaughtException(Thread t, Throwable e) { LOG.error("Thread " + t.getName() + " died with an uncaught exception", e); } }); } @Override protected void doShutdown() throws InterruptedException { LOG.info("Shutdown started"); queueExpirer.shutdown(); fileWatcher.shutdown(); LOG.info("Shutdown completed"); } @Override protected void doStartup() throws ServiceException { LOG.info("Startup started"); if (control.isFileWatcherEnabled()) { fileWatcher.startup(); } queueExpirer.startup(); LOG.info("Startup completed"); } public FacilityStatusManager getFacilityStatusManager() { return statusManager; } public PaulConfiguration getConfiguration() { return Objects.requireNonNull(configManager.getActiveConfig()); } public QueueManager getQueueManager() { return queueManager; } public ConfigurationManager getConfigManager() { return configManager; } public FileWatcher getFileWatcher() { return fileWatcher; } public EntityManagerFactory getEntityManagerFactory() { return entityManagerFactory; } public UncPathnameMapper getUncNameMapper() { return uncNameMapper; } public UserDetailsManager getUserDetailsManager() { return userDetailsManager; } public PaulFacilityMapper getFacilityMapper() { return facilityMapper; } public AclsHelper getAclsHelper() { return aclsHelper; } public AtomFeed getAtomFeed() { return atomFeed; } public final PaulControl getControl() { return control; } @Override public void start() { startup(); } @Override public void stop() { try { shutdown(); } catch (InterruptedException ex) { LOG.warn("Shutdown interrupted", ex); } } @Override public boolean isRunning() { return getState() == State.STARTED; } public void processStatusChange(String serviceName, String param) { Service service; switch (serviceName) { case "atomFeed": service = atomFeed; break; case "watcher": service = fileWatcher; break; default: throw new PaulException("unknown service: " + serviceName); } Service.State current = service.getState(); if (param == null) { return; } Status target = Status.valueOf(param); if (target == Status.forState(current) || Status.forState(current) == Status.TRANSITIONAL) { return; } if (target == Status.ON) { service.startStartup(); } else { service.startShutdown(); } switch (serviceName) { case "atomFeed": control.setAtomFeedEnabled(target == Status.ON); break; case "watcher": control.setFileWatcherEnabled(target == Status.ON); break; } PaulControl.save(control, entityManagerFactory); } }