Java tutorial
/* This file is part of Cyclos (www.cyclos.org). A project of the Social Trade Organisation (www.socialtrade.org). Cyclos 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 2 of the License, or (at your option) any later version. Cyclos 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 Cyclos; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package nl.strohalm.cyclos.services.application; import java.util.ArrayList; import java.util.Calendar; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; import java.util.Properties; import java.util.Set; import nl.strohalm.cyclos.dao.ApplicationDAO; import nl.strohalm.cyclos.dao.IndexOperationDAO; import nl.strohalm.cyclos.entities.Application; import nl.strohalm.cyclos.entities.Application.PasswordHash; import nl.strohalm.cyclos.entities.IndexOperation.EntityType; import nl.strohalm.cyclos.entities.IndexStatus; import nl.strohalm.cyclos.entities.Indexable; import nl.strohalm.cyclos.entities.access.SessionQuery; import nl.strohalm.cyclos.entities.accounts.LockedAccountsOnPayments; import nl.strohalm.cyclos.entities.accounts.SystemAccountOwner; import nl.strohalm.cyclos.entities.accounts.transactions.Invoice; import nl.strohalm.cyclos.entities.accounts.transactions.InvoiceQuery; import nl.strohalm.cyclos.entities.alerts.Alert; import nl.strohalm.cyclos.entities.alerts.SystemAlert; import nl.strohalm.cyclos.entities.alerts.SystemAlert.Alerts; import nl.strohalm.cyclos.entities.groups.Group; import nl.strohalm.cyclos.entities.members.messages.MessageBox; import nl.strohalm.cyclos.entities.members.messages.MessageQuery; import nl.strohalm.cyclos.initializations.LocalInitialization; import nl.strohalm.cyclos.scheduling.PollingTasksHandler; import nl.strohalm.cyclos.scheduling.SchedulingHandler; import nl.strohalm.cyclos.scheduling.polling.PollingTask; import nl.strohalm.cyclos.services.InitializingService; import nl.strohalm.cyclos.services.access.AccessServiceLocal; import nl.strohalm.cyclos.services.accounts.rates.RateServiceLocal; import nl.strohalm.cyclos.services.alerts.AlertServiceLocal; import nl.strohalm.cyclos.services.alerts.ErrorLogServiceLocal; import nl.strohalm.cyclos.services.elements.MessageServiceLocal; import nl.strohalm.cyclos.services.permissions.PermissionServiceLocal; import nl.strohalm.cyclos.services.transactions.InvoiceServiceLocal; import nl.strohalm.cyclos.utils.MessageResolver; import nl.strohalm.cyclos.utils.MessageResourcesLoadedListener; import nl.strohalm.cyclos.utils.TransactionHelper; import nl.strohalm.cyclos.utils.access.LoggedUser; import nl.strohalm.cyclos.utils.cache.Cache; import nl.strohalm.cyclos.utils.cache.CacheCallback; import nl.strohalm.cyclos.utils.cache.CacheManager; import nl.strohalm.cyclos.utils.instance.InstanceHandler; import nl.strohalm.cyclos.utils.lucene.IndexHandler; import nl.strohalm.cyclos.utils.query.PageHelper; import nl.strohalm.cyclos.utils.tasks.TaskRunner; import nl.strohalm.cyclos.utils.transaction.CurrentTransactionData; import nl.strohalm.cyclos.utils.transaction.TransactionCommitListener; import nl.strohalm.cyclos.utils.validation.ValidationException; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.time.DateUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.InitializingBean; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.support.TransactionCallbackWithoutResult; /** * Implementation class for the application service interface. * @author rafael */ public class ApplicationServiceImpl implements ApplicationServiceLocal, ApplicationContextAware, InitializingBean, MessageResourcesLoadedListener { private static final Log LOG = LogFactory.getLog(ApplicationServiceImpl.class); private static final String APPLICATION_CACHE_KEY = "application"; private static final String MINOR_VERSION_TAG = "_minor_"; private static final String minorVersion; private static String extract(final String cvsTagName) { if (cvsTagName == null) { return ""; } String result = cvsTagName; result = result.replaceAll("\\$Name:", ""); result = result.replaceAll("\\$", ""); result = result.replaceAll(" ", ""); if (StringUtils.isBlank(result) || !result.contains(MINOR_VERSION_TAG)) { return ""; } else { String[] tmp = StringUtils.splitByWholeSeparator(result, MINOR_VERSION_TAG); return tmp[tmp.length - 1]; } } private MessageResolver messageResolver; static { // the parameter is interpreted by CVS and expanded minorVersion = extract("$Name: not supported by cvs2svn $"); } private boolean initialized; private boolean initializing; private boolean runScheduling; private ApplicationContext applicationContext; private AccessServiceLocal accessService; private AlertServiceLocal alertService; private MessageServiceLocal messageService; private InvoiceServiceLocal invoiceService; private ErrorLogServiceLocal errorLogService; private RateServiceLocal rateService; private ApplicationDAO applicationDao; private IndexOperationDAO indexOperationDao; private SchedulingHandler schedulingHandler; private PollingTasksHandler pollingTasksHandler; private InstanceHandler instanceHandler; private IndexHandler indexHandler; private CacheManager cacheManager; private TaskRunner taskRunner; private long startupTime; private Properties cyclosProperties; private TransactionHelper transactionHelper; private LockedAccountsOnPayments lockedAccountsOnPayments; private final HashMap<Alerts, String> deferredEvents = new HashMap<Alerts, String>(); private PermissionServiceLocal permissionService; @Override public void afterPropertiesSet() throws Exception { try { lockedAccountsOnPayments = LockedAccountsOnPayments.valueOf(cyclosProperties .getProperty("cyclos.lockedAccountsOnPayments", LockedAccountsOnPayments.ORIGIN.name()) .toUpperCase()); } catch (Exception e) { StringBuilder message = new StringBuilder(); message.append("Invalid value for cyclos.lockedAccountsOnPayments: ") .append(cyclosProperties.getProperty("cyclos.lockedAccountsOnPayments")) .append(". Valid values are "); boolean first = true; for (LockedAccountsOnPayments item : LockedAccountsOnPayments.values()) { if (first) { first = false; } else { message.append(", "); } message.append(item.name().toLowerCase()); } throw new IllegalArgumentException(message.toString()); } } @Override public void awakePollingTask(final Class<? extends PollingTask> type) { if (pollingTasksHandler != null) { PollingTask pollingTask = pollingTasksHandler.get(type); if (pollingTask != null) { pollingTask.awake(); } } } @Override public void awakePollingTaskOnTransactionCommit(final Class<? extends PollingTask> type) { CurrentTransactionData.addTransactionCommitListener(new TransactionCommitListener() { @Override public void onTransactionCommit() { awakePollingTask(type); } }); } @Override public Calendar getAccountStatusEnabledSince() { return getApplication().getAccountStatusEnabledSince(); } @Override public ApplicationStatusVO getApplicationStatus() { final ApplicationStatusVO vo = new ApplicationStatusVO(); // Uptime period final long diff = System.currentTimeMillis() - startupTime; final int days = (int) (diff / DateUtils.MILLIS_PER_DAY); final int hours = (int) ((diff % DateUtils.MILLIS_PER_DAY) / DateUtils.MILLIS_PER_HOUR); vo.setUptimeDays(days); vo.setUptimeHours(hours); // Connected users SessionQuery sessions = new SessionQuery(); sessions.setGroups(permissionService.getAllVisibleGroups()); sessions.setPageForCount(); sessions.setNatures(Collections.singleton(Group.Nature.ADMIN)); vo.setConnectedAdmins(PageHelper.getTotalCount(accessService.searchSessions(sessions))); sessions.setNatures(Collections.singleton(Group.Nature.MEMBER)); vo.setConnectedMembers(PageHelper.getTotalCount(accessService.searchSessions(sessions))); sessions.setNatures(Collections.singleton(Group.Nature.BROKER)); vo.setConnectedBrokers(PageHelper.getTotalCount(accessService.searchSessions(sessions))); sessions.setNatures(Collections.singleton(Group.Nature.OPERATOR)); vo.setConnectedOperators(PageHelper.getTotalCount(accessService.searchSessions(sessions))); // Cyclos version vo.setCyclosVersion(getCyclosVersion()); // Number of alerts vo.setMemberAlerts(alertService.getAlertCount(Alert.Type.MEMBER)); vo.setSystemAlerts(alertService.getAlertCount(Alert.Type.SYSTEM)); vo.setErrors(errorLogService.getCount()); // Unread messages vo.setUnreadMessages(countUnreadMessages()); // Open invoices vo.setOpenInvoices(countOpenInvoices()); return vo; } @Override public String getCyclosVersion() { String suffix = ""; if (StringUtils.isNotBlank(minorVersion)) { suffix = " (" + minorVersion + ")"; } return getApplication().getVersion() + suffix; } @Override public Map<Class<? extends Indexable>, IndexStatus> getFullTextIndexesStatus() { final Map<Class<? extends Indexable>, IndexStatus> stats = new LinkedHashMap<Class<? extends Indexable>, IndexStatus>(); for (EntityType type : EntityType.values()) { Class<? extends Indexable> entityClass = type.getEntityClass(); stats.put(entityClass, indexHandler.getIndexStatus(entityClass)); } return stats; } @Override public LockedAccountsOnPayments getLockedAccountsOnPayments() { return lockedAccountsOnPayments; } public MessageResolver getMessageResolver() { return messageResolver; } @Override public PasswordHash getPasswordHash() { return getApplication().getPasswordHash(); } @Override public synchronized void initialize() { if (initialized || initializing) { return; } initializing = true; try { // Store the startup time startupTime = System.currentTimeMillis(); // Set AWT to headless mode. This way we can use XFree86 libs // on *nix systems without an X server running. setHeadlessMode(); // The InitializingServices should be only initialized when scheduling is used on this cyclos instance. runScheduling = !Boolean.valueOf(cyclosProperties.getProperty("cyclos.disableScheduling", "false")); if (runScheduling) { // Run the initializations (beans of type InitializingService) Set<String> beanNames = applicationContext.getBeansOfType(InitializingService.class).keySet(); taskRunner.runInitializations(beanNames); // Start both scheduling and polling tasks handlers schedulingHandler.start(); pollingTasksHandler.start(); } // Run the initializations Collection<LocalInitialization> initializations = applicationContext .getBeansOfType(LocalInitialization.class).values(); runAll(initializations); if (runScheduling) { // Create a system alert transactionHelper.runAsync(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(final TransactionStatus status) { // at this point, the resource bundle for translations is not loaded yet // thus, we need to defer the creation of the event deferEvent(SystemAlert.Alerts.APPLICATION_RESTARTED, instanceHandler.getId()); } }); } initialized = true; // add this object as a listener to the messageResolver, which will inform (notify) this // object when the translation resource bundles have been loaded, so that finally alerts can be created messageResolver.addMessageResourcesLoadedListener(this); } finally { initializing = false; } } @Override public boolean isInitialized() { return initialized && !initializing; } @Override public boolean isOnline() { Application app = getApplication(); return app != null && app.isOnline(); } @Override public boolean isRunScheduling() { return runScheduling; } /** * * @see nl.strohalm.cyclos.utils.MessageResourcesLoadedListener#onApplicationResourcesLoaded() */ @Override public void onApplicationResourcesLoaded() { Iterator<Alerts> it = deferredEvents.keySet().iterator(); while (it.hasNext()) { Alerts key = it.next(); String val = deferredEvents.get(key); alertService.create(key, val); } } @Override public void purgeIndexOperations(final Calendar time) { Calendar limit = (Calendar) time.clone(); limit.add(Calendar.HOUR_OF_DAY, -24); indexOperationDao.deleteBefore(limit); } @Override public void rebuildIndexes(final Class<? extends Indexable> entityType) { for (Class<? extends Indexable> entityClass : resolveIndexedClasses(entityType)) { indexHandler.rebuild(entityClass); } } public void setAccessServiceLocal(final AccessServiceLocal accessService) { this.accessService = accessService; } public void setAlertServiceLocal(final AlertServiceLocal alertService) { this.alertService = alertService; } @Override public void setApplicationContext(final ApplicationContext applicationContext) { this.applicationContext = applicationContext; } public void setApplicationDao(final ApplicationDAO applicationDao) { this.applicationDao = applicationDao; } public void setCacheManager(final CacheManager cacheManager) { this.cacheManager = cacheManager; } public void setCyclosProperties(final Properties cyclosProperties) { this.cyclosProperties = cyclosProperties; } public void setErrorLogServiceLocal(final ErrorLogServiceLocal errorLogService) { this.errorLogService = errorLogService; } public void setIndexHandler(final IndexHandler indexHandler) { this.indexHandler = indexHandler; } public void setIndexOperationDao(final IndexOperationDAO indexOperationDao) { this.indexOperationDao = indexOperationDao; } public void setInstanceHandler(final InstanceHandler instanceHandler) { this.instanceHandler = instanceHandler; } public void setInvoiceServiceLocal(final InvoiceServiceLocal invoiceService) { this.invoiceService = invoiceService; } public void setMessageResolver(final MessageResolver messageResolver) { this.messageResolver = messageResolver; } public void setMessageServiceLocal(final MessageServiceLocal messageService) { this.messageService = messageService; } @Override public void setOnline(final boolean online) { Application application = getApplication(); final boolean changed = application.isOnline() != online; if (changed) { if (online && (rateService.checkPendingRateInitializations(null) != null)) { throw new ValidationException("rates.error.notOnlineWhileRateInitsPending"); } application.setOnline(online); applicationDao.update(application); getCache().remove(APPLICATION_CACHE_KEY); if (!online) { // Disconnect all logged users but the current user accessService.disconnectAllButLogged(); } } } public void setPermissionServiceLocal(final PermissionServiceLocal permissionService) { this.permissionService = permissionService; } public void setPollingTasksHandler(final PollingTasksHandler pollingTasksHandler) { this.pollingTasksHandler = pollingTasksHandler; } public void setRateServiceLocal(final RateServiceLocal rateService) { this.rateService = rateService; } public void setSchedulingHandler(final SchedulingHandler schedulingHandler) { this.schedulingHandler = schedulingHandler; } public void setTaskRunner(final TaskRunner taskRunner) { this.taskRunner = taskRunner; } public void setTransactionHelper(final TransactionHelper transactionHelper) { this.transactionHelper = transactionHelper; } @Override public void shutdown() { initialized = false; transactionHelper.runInCurrentThread(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(final TransactionStatus status) { alertService.create(SystemAlert.Alerts.APPLICATION_SHUTDOWN, instanceHandler.getId()); } }); applicationDao.shutdownDBIfNeeded(); } private int countOpenInvoices() { final InvoiceQuery query = new InvoiceQuery(); query.setOwner(SystemAccountOwner.instance()); query.setDirection(InvoiceQuery.Direction.INCOMING); query.setStatus(Invoice.Status.OPEN); query.setPageForCount(); return PageHelper.getTotalCount(invoiceService.search(query)); } private int countUnreadMessages() { final MessageQuery query = new MessageQuery(); query.setGetter(LoggedUser.element()); query.setMessageBox(MessageBox.INBOX); query.setRead(false); query.setPageForCount(); return PageHelper.getTotalCount(messageService.search(query)); } /** * Defer the event creation for later firing * * @param applicationRestarted Alert type * @param id application id */ private void deferEvent(final Alerts applicationRestarted, final String id) { deferredEvents.put(applicationRestarted, id); } private Application getApplication() { return getCache().get(APPLICATION_CACHE_KEY, new CacheCallback() { @Override public Object retrieve() { return applicationDao.read(); } }); } private Cache getCache() { return cacheManager.getCache("cyclos.Application"); } /** * Returns all indexed classes if the parameter is null, or a singleton collection otherwise */ private Collection<Class<? extends Indexable>> resolveIndexedClasses( final Class<? extends Indexable> entityType) { if (entityType == null) { Collection<Class<? extends Indexable>> entityClasses = new ArrayList<Class<? extends Indexable>>(); for (EntityType type : EntityType.values()) { entityClasses.add(type.getEntityClass()); } return entityClasses; } else { return Collections.<Class<? extends Indexable>>singleton(entityType); } } /** * Run all given local initializations in its own transaction */ private void runAll(final Collection<LocalInitialization> initializations) { for (final LocalInitialization initialization : initializations) { LOG.debug(String.format("Running initialization (%s)...", initialization.getName())); transactionHelper.runInCurrentThread(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(final TransactionStatus status) { initialization.initialize(); } }); } } private void setHeadlessMode() { System.setProperty("java.awt.headless", "true"); } }