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.publish; import org.opencms.db.CmsDbContext; import org.opencms.db.CmsDriverManager; import org.opencms.db.CmsPublishList; import org.opencms.db.CmsUserSettings; import org.opencms.db.I_CmsDbContextFactory; import org.opencms.file.CmsDataAccessException; import org.opencms.file.CmsObject; import org.opencms.file.CmsRequestContext; import org.opencms.file.CmsResource; import org.opencms.file.CmsUser; import org.opencms.lock.CmsLockType; import org.opencms.main.CmsEvent; import org.opencms.main.CmsException; import org.opencms.main.CmsInitException; import org.opencms.main.CmsLog; import org.opencms.main.I_CmsEventListener; import org.opencms.main.OpenCms; import org.opencms.monitor.CmsMemoryMonitor; import org.opencms.report.I_CmsReport; import org.opencms.security.CmsAuthentificationException; import org.opencms.security.CmsRole; import org.opencms.util.CmsUUID; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import org.apache.commons.logging.Log; /** * This class is responsible for the publish process.<p> * * @since 6.5.5 */ public final class CmsPublishEngine { /** The log object for this class. */ private static final Log LOG = CmsLog.getLog(CmsPublishEngine.class); /** The id of the admin user. */ private CmsUUID m_adminUserId; /** The current running publish job. */ private CmsPublishThread m_currentPublishThread; /** The runtime info factory used during publishing. */ private final I_CmsDbContextFactory m_dbContextFactory; /** The driver manager instance. */ private CmsDriverManager m_driverManager; /** The engine state. */ private CmsPublishEngineState m_engineState; /** The publish listeners. */ private final CmsPublishListenerCollection m_listeners; /** The publish history list with already published jobs. */ private final CmsPublishHistory m_publishHistory; /** The queue with still waiting publish job. */ private final CmsPublishQueue m_publishQueue; /** The amount of time the system will wait for a running publish job during shutdown. */ private int m_publishQueueShutdowntime; /** Is set during shutdown. */ private boolean m_shuttingDown; /** * Default constructor.<p> * * @param dbContextFactory the initialized OpenCms runtime info factory * * @throws CmsInitException if the configured path to store the publish reports is not accessible */ public CmsPublishEngine(I_CmsDbContextFactory dbContextFactory) throws CmsInitException { if (OpenCms.getRunLevel() > OpenCms.RUNLEVEL_2_INITIALIZING) { // OpenCms is already initialized throw new CmsInitException( org.opencms.main.Messages.get().container(org.opencms.main.Messages.ERR_ALREADY_INITIALIZED_0)); } if (dbContextFactory == null) { throw new CmsInitException(org.opencms.main.Messages.get() .container(org.opencms.main.Messages.ERR_CRITICAL_NO_DB_CONTEXT_0)); } // initialize the db context factory m_dbContextFactory = dbContextFactory; // initialize publish queue m_publishQueue = new CmsPublishQueue(this); // initialize publish history m_publishHistory = new CmsPublishHistory(this); // initialize event handling m_listeners = new CmsPublishListenerCollection(this); // set engine state to normal processing m_engineState = CmsPublishEngineState.ENGINE_STARTED; if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_PUBLISH_ENGINE_READY_0)); } } /** * Abandons the given publish thread.<p> */ public void abandonThread() { if (!m_currentPublishThread.isAlive()) { // thread is dead if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_PUBLISH_ENGINE_DEAD_JOB_0)); } } else { // thread is not dead, and we suppose it hangs :( if (LOG.isWarnEnabled()) { LOG.warn(Messages.get().getBundle().key(Messages.LOG_THREADSTORE_PUBLISH_THREAD_INTERRUPT_2, m_currentPublishThread.getName(), m_currentPublishThread.getUUID())); } m_currentPublishThread.interrupt(); } // just throw it away m_currentPublishThread = null; // and try again checkCurrentPublishJobThread(); } /** * Controls the publish process.<p> */ public synchronized void checkCurrentPublishJobThread() { // give the finishing publish thread enough time to clean up try { Thread.sleep(200); } catch (InterruptedException e) { // ignore } // create a publish thread only if engine is started if (m_engineState != CmsPublishEngineState.ENGINE_STARTED) { return; } if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_PUBLISH_ENGINE_RUNNING_0)); } // check the driver manager if ((m_driverManager == null) || (m_dbContextFactory == null)) { LOG.error(Messages.get().getBundle().key(Messages.ERR_PUBLISH_ENGINE_NOT_INITIALIZED_0)); // without these there is nothing we can do return; } // there is no running publish job if (m_currentPublishThread == null) { // but something is waiting in the queue if (!m_publishQueue.isEmpty()) { // start the next waiting publish job CmsPublishJobInfoBean publishJob = m_publishQueue.next(); m_currentPublishThread = new CmsPublishThread(this, publishJob); m_currentPublishThread.start(); } else { // nothing to do if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_PUBLISH_ENGINE_NO_RUNNING_JOB_0)); } } return; } if (m_currentPublishThread.isAlive()) { // normal running // wait until it is finished if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_PUBLISH_ENGINE_WAITING_0)); } } else { // clean up the dead thread abandonThread(); } } /** * Enqueues a new publish job with the given information in publish queue.<p> * * All resources should already be locked.<p> * * If possible, the publish job starts immediately.<p> * * @param cms the cms context to publish for * @param publishList the resources to publish * @param report the report to write to * * @throws CmsException if something goes wrong while cloning the cms context */ public void enqueuePublishJob(CmsObject cms, CmsPublishList publishList, I_CmsReport report) throws CmsException { // check the driver manager if ((m_driverManager == null) || (m_dbContextFactory == null)) { // the resources are unlocked in the driver manager throw new CmsPublishException(Messages.get().container(Messages.ERR_PUBLISH_ENGINE_NOT_INITIALIZED_0)); } // prevent new jobs if the engine is disabled if (m_shuttingDown || (!isEnabled() && !OpenCms.getRoleManager().hasRole(cms, CmsRole.ROOT_ADMIN))) { // the resources are unlocked in the driver manager throw new CmsPublishException(Messages.get().container(Messages.ERR_PUBLISH_ENGINE_DISABLED_0)); } // create the publish job CmsPublishJobInfoBean publishJob = new CmsPublishJobInfoBean(cms, publishList, report); try { // enqueue it and m_publishQueue.add(publishJob); // notify all listeners m_listeners.fireEnqueued(new CmsPublishJobBase(publishJob)); } catch (Throwable t) { // we really really need to catch everything here, or else the queue status is broken if (m_publishQueue.contains(publishJob)) { m_publishQueue.remove(publishJob); } // throw the exception again throw new CmsException( Messages.get().container(Messages.ERR_PUBLISH_ENGINE_QUEUE_1, publishJob.getPublishHistoryId()), t); } // try to start the publish job immediately checkCurrentPublishJobThread(); } /** * Returns a publish job based on its publish history id.<p> * * The returned publish job may be an enqueued, running or finished publish job.<p> * * @param publishHistoryId the publish history id to search for * * @return the publish job with the given publish history id, or <code>null</code> */ public CmsPublishJobBase getJobByPublishHistoryId(CmsUUID publishHistoryId) { // try current running job if ((m_currentPublishThread != null) && m_currentPublishThread.getPublishJob().getPublishHistoryId().equals(publishHistoryId)) { return new CmsPublishJobRunning(m_currentPublishThread.getPublishJob()); } // try enqueued jobs Iterator<CmsPublishJobEnqueued> itEnqueuedJobs = getPublishQueue().asList().iterator(); while (itEnqueuedJobs.hasNext()) { CmsPublishJobEnqueued enqueuedJob = itEnqueuedJobs.next(); if (enqueuedJob.getPublishList().getPublishHistoryId().equals(publishHistoryId)) { return enqueuedJob; } } // try finished jobs Iterator<CmsPublishJobFinished> itFinishedJobs = getPublishHistory().asList().iterator(); while (itFinishedJobs.hasNext()) { CmsPublishJobFinished finishedJob = itFinishedJobs.next(); if (finishedJob.getPublishHistoryId().equals(publishHistoryId)) { return finishedJob; } } return null; } /** * Sets the driver manager instance.<p> * * @param driverManager the driver manager instance */ public void setDriverManager(CmsDriverManager driverManager) { m_driverManager = driverManager; CmsDbContext dbc = m_dbContextFactory.getDbContext(); try { m_adminUserId = m_driverManager.readUser(dbc, OpenCms.getDefaultUsers().getUserAdmin()).getId(); } catch (CmsException e) { dbc.rollback(); LOG.error(e.getLocalizedMessage(), e); } finally { dbc.clear(); } } /** * Shuts down all this static export manager.<p> * * NOTE: this method may or may NOT be called (i.e. kill -9 in the stop script), if a system is stopped.<p> * * This is required since there may still be a thread running when the system is being shut down.<p> */ public void shutDown() { if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(org.opencms.main.Messages.get().getBundle() .key(org.opencms.main.Messages.INIT_SHUTDOWN_START_1, this.getClass().getName())); } // prevent new publish jobs are accepted m_shuttingDown = true; // if a job is currently running, // wait the specified amount of time, // then write an abort message to the report if (m_currentPublishThread != null) { // if a shutdown time is defined, wait if a publish process is running if (m_publishQueueShutdowntime > 0) { synchronized (this) { try { Thread.sleep(m_publishQueueShutdowntime * 1000); } catch (InterruptedException exc) { // ignore } } } if (m_currentPublishThread != null) { CmsPublishJobInfoBean publishJob = m_currentPublishThread.getPublishJob(); try { abortPublishJob(m_adminUserId, new CmsPublishJobEnqueued(publishJob), false); } catch (CmsException e) { if (LOG.isErrorEnabled()) { LOG.error(e.getLocalizedMessage(), e); } } } } // write the log CmsDbContext dbc = getDbContext(null); try { m_driverManager.updateLog(dbc); } catch (CmsDataAccessException e) { if (LOG.isErrorEnabled()) { LOG.error(e.getLocalizedMessage(), e); } } finally { dbc.clear(); } if (CmsLog.INIT.isInfoEnabled()) { CmsLog.INIT.info(org.opencms.staticexport.Messages.get().getBundle() .key(org.opencms.staticexport.Messages.INIT_SHUTDOWN_1, this.getClass().getName())); } } /** * Aborts the given publish job.<p> * * @param userId the id of user that wants to abort the given publish job * @param publishJob the publish job to abort * @param removeJob indicates if the job will be removed or added to history * * @throws CmsException if there is some problem during unlocking the resources * @throws CmsPublishException if the publish job can not be aborted */ protected void abortPublishJob(CmsUUID userId, CmsPublishJobEnqueued publishJob, boolean removeJob) throws CmsException, CmsPublishException { // abort event should be raised before the job is removed implicitly m_listeners.fireAbort(userId, publishJob); if ((m_currentPublishThread == null) || !publishJob.m_publishJob.equals(m_currentPublishThread.getPublishJob())) { // engine is currently publishing another job or is not publishing if (!m_publishQueue.abortPublishJob(publishJob.m_publishJob)) { // job not found throw new CmsPublishException( Messages.get().container(Messages.ERR_PUBLISH_ENGINE_MISSING_PUBLISH_JOB_0)); } } else if (!m_shuttingDown) { // engine is currently publishing the job to abort m_currentPublishThread.abort(); } else if (m_shuttingDown && (m_currentPublishThread != null)) { // aborting the current job during shut down I_CmsReport report = m_currentPublishThread.getReport(); report.println(); report.println(); report.println(Messages.get().container(Messages.RPT_PUBLISH_JOB_ABORT_SHUTDOWN_0), I_CmsReport.FORMAT_ERROR); report.println(); } // unlock all resources if (publishJob.getPublishList() != null) { unlockPublishList(publishJob.m_publishJob); } // keep job if requested if (!removeJob) { // set finish info publishJob.m_publishJob.finish(); getPublishHistory().add(publishJob.m_publishJob); } else { getPublishQueue().remove(publishJob.m_publishJob); } } /** * Adds a publish listener to listen on publish events.<p> * * @param listener the publish listener to add */ protected void addPublishListener(I_CmsPublishEventListener listener) { m_listeners.add(listener); } /** * Disables the publish engine, i.e. publish jobs are not accepted.<p> */ protected void disableEngine() { m_engineState = CmsPublishEngineState.ENGINE_DISABLED; } /** * Enables the publish engine, i.e. publish jobs are accepted.<p> */ protected void enableEngine() { m_engineState = CmsPublishEngineState.ENGINE_STARTED; // start publish job if jobs waiting if ((m_currentPublishThread == null) && !m_publishQueue.isEmpty()) { checkCurrentPublishJobThread(); } } /** * Returns the current running publish job.<p> * * @return the current running publish job */ protected CmsPublishThread getCurrentPublishJob() { return m_currentPublishThread; } /** * Returns the a new db context object.<p> * * @param ctx optional request context, can be <code>null</code> * * @return the a new db context object */ protected CmsDbContext getDbContext(CmsRequestContext ctx) { return m_dbContextFactory.getDbContext(ctx); } /** * Returns the driver manager instance.<p> * * @return the driver manager instance */ protected CmsDriverManager getDriverManager() { return m_driverManager; } /** * Returns the publish history list with already publish job.<p> * * @return the publish history list with already publish job */ protected CmsPublishHistory getPublishHistory() { return m_publishHistory; } /** * Returns the queue with still waiting publish job.<p> * * @return the queue with still waiting publish job */ protected CmsPublishQueue getPublishQueue() { return m_publishQueue; } /** * Returns the content of the publish report assigned to the given publish job.<p> * * @param publishJob the published job * @return the content of the assigned publish report * * @throws CmsException if something goes wrong */ protected byte[] getReportContents(CmsPublishJobFinished publishJob) throws CmsException { byte[] result = null; CmsDbContext dbc = m_dbContextFactory.getDbContext(); try { result = m_driverManager.readPublishReportContents(dbc, publishJob.getPublishHistoryId()); } catch (CmsException e) { dbc.rollback(); LOG.error(e.getLocalizedMessage(), e); throw e; } finally { dbc.clear(); } return result; } /** * Returns the user identified by the given id.<p> * * @param userId the id of the user to retrieve * * @return the user identified by the given id */ protected CmsUser getUser(CmsUUID userId) { CmsDbContext dbc = m_dbContextFactory.getDbContext(); try { return m_driverManager.readUser(dbc, userId); } catch (CmsException e) { dbc.rollback(); LOG.error(e.getLocalizedMessage(), e); } finally { dbc.clear(); } return null; } /** * Initializes the publish engine.<p> * * @param adminCms the admin cms * @param publishQueuePersistance flag if the queue is persisted * @param publishQueueShutdowntime amount of time to wait for a publish job during shutdown * * @throws CmsException if something goes wrong */ protected void initialize(CmsObject adminCms, boolean publishQueuePersistance, int publishQueueShutdowntime) throws CmsException { // check the driver manager if ((m_driverManager == null) || (m_dbContextFactory == null)) { throw new CmsPublishException(Messages.get().container(Messages.ERR_PUBLISH_ENGINE_NOT_INITIALIZED_0)); } m_publishQueueShutdowntime = publishQueueShutdowntime; // initially the engine is stopped, must be restartet after full system initialization m_engineState = CmsPublishEngineState.ENGINE_STOPPED; // read the publish history from the repository m_publishHistory.initialize(); // read the queue from the repository m_publishQueue.initialize(adminCms, publishQueuePersistance); } /** * Returns the working state, that is if no publish job * is waiting to be processed and there is no current running * publish job.<p> * * @return the working state */ protected boolean isRunning() { return (((m_engineState == CmsPublishEngineState.ENGINE_STARTED) && !m_publishQueue.isEmpty()) || (m_currentPublishThread != null)); } /** * Sets publish locks of resources in a publish list.<p> * * @param publishJob the publish job * @throws CmsException if something goes wrong */ protected void lockPublishList(CmsPublishJobInfoBean publishJob) throws CmsException { CmsPublishList publishList = publishJob.getPublishList(); // lock them CmsDbContext dbc = getDbContext(publishJob.getCmsObject().getRequestContext()); try { Iterator<CmsResource> itResources = publishList.getAllResources().iterator(); while (itResources.hasNext()) { CmsResource resource = itResources.next(); m_driverManager.lockResource(dbc, resource, CmsLockType.PUBLISH); } } catch (CmsException e) { dbc.rollback(); LOG.error(e.getLocalizedMessage(), e); throw e; } finally { dbc.clear(); } } /** * Signalizes that the publish thread finishes.<p> * * @param publishJob the finished publish job */ protected void publishJobFinished(CmsPublishJobInfoBean publishJob) { // in order to avoid not removable publish locks, unlock all assigned resources again try { unlockPublishList(publishJob); } catch (Throwable t) { // log failure, most likely a database problem LOG.error(t.getLocalizedMessage(), t); } // trigger the old event mechanism CmsDbContext dbc = m_dbContextFactory.getDbContext(publishJob.getCmsObject().getRequestContext()); try { // fire an event that a project has been published Map<String, Object> eventData = new HashMap<String, Object>(); eventData.put(I_CmsEventListener.KEY_REPORT, publishJob.getPublishReport()); eventData.put(I_CmsEventListener.KEY_PUBLISHID, publishJob.getPublishList().getPublishHistoryId().toString()); eventData.put(I_CmsEventListener.KEY_PROJECTID, dbc.currentProject().getUuid()); eventData.put(I_CmsEventListener.KEY_DBCONTEXT, dbc); CmsEvent afterPublishEvent = new CmsEvent(I_CmsEventListener.EVENT_PUBLISH_PROJECT, eventData); OpenCms.fireCmsEvent(afterPublishEvent); } catch (Throwable t) { dbc.rollback(); LOG.error(t); // catch every thing including runtime exceptions publishJob.getPublishReport().println(t); } finally { try { dbc.clear(); } catch (Throwable t) { // ignore } dbc = null; } try { // fire the publish finish event m_listeners.fireFinish(new CmsPublishJobRunning(publishJob)); } catch (Throwable t) { // log failure, most likely a database problem LOG.error(t.getLocalizedMessage(), t); } try { // finish the job publishJob.finish(); } catch (Throwable t) { // log failure, most likely a database problem LOG.error(t.getLocalizedMessage(), t); } try { // put the publish job into the history list m_publishHistory.add(publishJob); } catch (Throwable t) { // log failure, most likely a database problem LOG.error(t.getLocalizedMessage(), t); } if (Thread.currentThread() == m_currentPublishThread) { // wipe the dead thread, only if this thread has not been abandoned m_currentPublishThread = null; } // clear the published resources cache OpenCms.getMemoryMonitor().flushCache(CmsMemoryMonitor.CacheType.PUBLISHED_RESOURCES); // try to start a new publish job checkCurrentPublishJobThread(); } /** * A publish job has been permanently removed from the history.<p> * * @param publishJob the removed publish job */ protected void publishJobRemoved(CmsPublishJobInfoBean publishJob) { // a publish job has been removed m_listeners.fireRemove(new CmsPublishJobFinished(publishJob)); } /** * Signalizes that the publish thread starts.<p> * * @param publishJob the started publish job */ protected void publishJobStarted(CmsPublishJobInfoBean publishJob) { // update the job m_publishQueue.update(publishJob); // fire the publish start event m_listeners.fireStart(new CmsPublishJobEnqueued(publishJob)); } /** * Removes the given publish listener.<p> * * @param listener the publish listener to remove */ protected void removePublishListener(I_CmsPublishEventListener listener) { m_listeners.remove(listener); } /** * Sends a message to the given user, if publish notification is enabled or an error is shown in the message.<p> * * @param toUserId the id of the user to send the message to * @param message the message to send * @param hasErrors flag to determine if the message to send shows an error */ protected void sendMessage(CmsUUID toUserId, String message, boolean hasErrors) { CmsDbContext dbc = m_dbContextFactory.getDbContext(); try { CmsUser toUser = m_driverManager.readUser(dbc, toUserId); CmsUserSettings settings = new CmsUserSettings(toUser); if (settings.getShowPublishNotification() || hasErrors) { // only show message if publish notification is enabled or the message shows an error OpenCms.getSessionManager().sendBroadcast(null, message, toUser); } } catch (CmsException e) { dbc.rollback(); LOG.error(e.getLocalizedMessage(), e); } finally { dbc.clear(); } } /** * Starts the publish engine, i.e. publish jobs are accepted and processed.<p> */ protected void startEngine() { if (m_engineState != CmsPublishEngineState.ENGINE_STARTED) { m_engineState = CmsPublishEngineState.ENGINE_STARTED; // start publish job if jobs waiting if ((m_currentPublishThread == null) && !m_publishQueue.isEmpty()) { checkCurrentPublishJobThread(); } } } /** * Stops the publish engine, i.e. publish jobs are still accepted but not published.<p> */ protected void stopEngine() { m_engineState = CmsPublishEngineState.ENGINE_STOPPED; } /** * Removes all publish locks of resources in a publish list of a publish job.<p> * * @param publishJob the publish job * @throws CmsException if something goes wrong */ protected void unlockPublishList(CmsPublishJobInfoBean publishJob) throws CmsException { CmsPublishList publishList = publishJob.getPublishList(); List<CmsResource> allResources = publishList.getAllResources(); // unlock them CmsDbContext dbc = getDbContext(publishJob.getCmsObject().getRequestContext()); try { Iterator<CmsResource> itResources = allResources.iterator(); while (itResources.hasNext()) { CmsResource resource = itResources.next(); m_driverManager.unlockResource(dbc, resource, true, true); } } catch (CmsException e) { dbc.rollback(); LOG.error(e.getLocalizedMessage(), e); throw e; } finally { dbc.clear(); } } /** * Returns <code>true</code> if the login manager allows login.<p> * * @return if enabled */ private boolean isEnabled() { try { if ((m_engineState == CmsPublishEngineState.ENGINE_STOPPED) || (m_engineState == CmsPublishEngineState.ENGINE_STARTED)) { OpenCms.getLoginManager().checkLoginAllowed(); return true; } else { return false; } } catch (CmsAuthentificationException e) { return false; } } }