Java tutorial
/* * This library is part of OpenCms - * the Open Source Content Management System * * Copyright (c) Alkacon Software GmbH (http://www.alkacon.com) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * For further information about Alkacon Software GmbH, please see the * company website: http://www.alkacon.com * * For further information about OpenCms, please see the * project website: http://www.opencms.org * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package org.opencms.search; import org.opencms.file.CmsResource; import org.opencms.i18n.CmsMessageContainer; import org.opencms.main.CmsLog; import org.opencms.report.CmsLogReport; import org.opencms.report.I_CmsReport; import java.io.IOException; import org.apache.commons.logging.Log; import org.apache.lucene.document.Document; /** * Implements the management of indexing threads.<p> * * @since 6.0.0 */ public class CmsIndexingThreadManager { /** The log object for this class. */ private static final Log LOG = CmsLog.getLog(CmsIndexingThreadManager.class); /** Number of threads abandoned. */ private int m_abandonedCounter; /** The time the last error was written to the log. */ private long m_lastLogErrorTime; /** The time the last warning was written to the log. */ private long m_lastLogWarnTime; /** The maximum number of modifications before a commit in the search index is triggered. */ private int m_maxModificationsBeforeCommit; /** Number of thread returned. */ private int m_returnedCounter; /** Overall number of threads started. */ private int m_startedCounter; /** Timeout for abandoning threads. */ private long m_timeout; /** * Creates and starts a thread manager for indexing threads.<p> * * @param timeout timeout after a thread is abandoned * @param maxModificationsBeforeCommit the maximum number of modifications before a commit in the search index is triggered */ public CmsIndexingThreadManager(long timeout, int maxModificationsBeforeCommit) { m_timeout = timeout; m_maxModificationsBeforeCommit = maxModificationsBeforeCommit; } /** * Creates and starts a new indexing thread for a resource.<p> * * After an indexing thread was started, the manager suspends itself * and waits for an amount of time specified by the <code>timeout</code> * value. If the timeout value is reached, the indexing thread is * aborted by an interrupt signal.<p> * * @param indexer the VFS indexer to create the index thread for * @param writer the index writer that can update the index * @param res the resource */ public void createIndexingThread(CmsVfsIndexer indexer, I_CmsIndexWriter writer, CmsResource res) { I_CmsReport report = indexer.getReport(); m_startedCounter++; CmsIndexingThread thread = new CmsIndexingThread(indexer.getCms(), res, indexer.getIndex(), m_startedCounter, report); thread.setPriority(Thread.MIN_PRIORITY); thread.start(); try { thread.join(m_timeout); } catch (InterruptedException e) { // ignore } if (thread.isAlive()) { // the thread has not finished - so it must be marked as an abandoned thread m_abandonedCounter++; thread.interrupt(); if (LOG.isWarnEnabled()) { LOG.warn(Messages.get().getBundle().key(Messages.LOG_INDEXING_TIMEOUT_1, res.getRootPath())); } if (report != null) { report.println(); report.print(org.opencms.report.Messages.get().container(org.opencms.report.Messages.RPT_FAILED_0), I_CmsReport.FORMAT_WARNING); report.println(Messages.get().container(Messages.RPT_SEARCH_INDEXING_TIMEOUT_1, res.getRootPath()), I_CmsReport.FORMAT_WARNING); } } else { // the thread finished normally m_returnedCounter++; } Document doc = thread.getResult(); if (doc != null) { // write the document to the index indexer.updateResource(writer, res.getRootPath(), doc); } if ((m_startedCounter % m_maxModificationsBeforeCommit) == 0) { try { writer.commit(); } catch (IOException e) { if (LOG.isWarnEnabled()) { LOG.warn(Messages.get().getBundle().key(Messages.LOG_IO_INDEX_WRITER_COMMIT_2, indexer.getIndex().getName(), indexer.getIndex().getPath()), e); } } } } /** * Returns if the indexing manager still have indexing threads.<p> * * @return true if the indexing manager still have indexing threads */ public boolean isRunning() { if (m_lastLogErrorTime <= 0) { m_lastLogErrorTime = System.currentTimeMillis(); m_lastLogWarnTime = m_lastLogErrorTime; } else { long currentTime = System.currentTimeMillis(); if ((currentTime - m_lastLogWarnTime) > 30000) { // write warning to log after 30 seconds if (LOG.isWarnEnabled()) { LOG.warn(Messages.get().getBundle().key(Messages.LOG_WAITING_ABANDONED_THREADS_2, new Integer(m_abandonedCounter), new Integer((m_startedCounter - m_returnedCounter)))); } m_lastLogWarnTime = currentTime; } if ((currentTime - m_lastLogErrorTime) > 600000) { // write error to log after 10 minutes LOG.error(Messages.get().getBundle().key(Messages.LOG_WAITING_ABANDONED_THREADS_2, new Integer(m_abandonedCounter), new Integer((m_startedCounter - m_returnedCounter)))); m_lastLogErrorTime = currentTime; } } boolean result = (m_returnedCounter + m_abandonedCounter) < m_startedCounter; if (result && LOG.isInfoEnabled()) { // write a note to the log that all threads have finished LOG.info(Messages.get().getBundle().key(Messages.LOG_THREADS_FINISHED_0)); } return result; } /** * Writes statistical information to the report.<p> * * The method reports the total number of threads started * (equals to the number of indexed files), the number of returned * threads (equals to the number of successfully indexed files), * and the number of abandoned threads (hanging threads reaching the timeout). * * @param report the report to write the statistics to */ public void reportStatistics(I_CmsReport report) { if (report != null) { CmsMessageContainer message = Messages.get().container(Messages.RPT_SEARCH_INDEXING_STATS_4, new Object[] { new Integer(m_startedCounter), new Integer(m_returnedCounter), new Integer(m_abandonedCounter), report.formatRuntime() }); report.println(message); if (!(report instanceof CmsLogReport) && LOG.isInfoEnabled()) { // only write to the log if report is not already a log report LOG.info(message.key()); } } } }