mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-06-30 18:15:39 +00:00
29f7f5d073
28236: ALF-8810: Removed trailing space from discussion.discussion_for Italian translation
28241: Incremented version revision for 3.4.4
28284: ALF-835 - WCM/AVM: copy (empty) folder into itself
28285: ALF-6863: More than one cifs device breaks the web UI (explorer)
28290: ALF-8840: user-*.atomentry.ftl
28291: ALF-6863: Continuation of fix by Arseny
28336: ALF-8768: Fixed typo in comment on wcm-bootstrap-context.xml
28363: Merged DEV to V3.4-BUG-FIX
28262: ALF-8847: WCM: OrphanReaper contention throws error after 39 retries.
Checkin Comment:
Use JobLockService to make sure that only one OrphanReaper job is working.
Generate list of nodes that must be processed in OrphanReaper.doBatch() transaction.
28386: ALF-9100: Merged PATCHES/V3.4.1 to V3.4-BUG-FIX
28249: ALF-8946: Avoid one full table scan per batch in full reindex
- Now each batch scans a single time sample, dynamically adjusted based on the number of transactions
in the previous sample, always aiming for 1000 transactions per sample.
28394: Fixed ALF-9090: NPE during inter-cluster subsystem messaging
- Bean ID is a List<String> and might not be recognized on receiving machine
- Log warning when bean ID is not available (unsymmetrical configuration, perhaps?)
28396: Merged DEV to V3.4-BUG-FIX
28384: ALF-6150: Initial state lost when non-versionable document is saved for the first time
Creation of new version of document before writing its content was added to
- AbstractAlfrescoMethodHandler->putDocument (this method is used by Office 2003, 2007)
- VtiIfHeaderAction->doPut (this method is used by Office 2007 and 2010 on Windows 7)
Creation of new version was added twice to AbstractAlfrescoMethodHandler to avoid affecting
initial version when transaction is committed.
28432: Merged DEV to V3.4-BUG-FIX
28431: ALF-8530: Pressing the info icon creates an unrecorded file in the ContentStore
Use ContentService.getTempWriter() in BaseContentNode$TemplateContentData.getContentAsText() method.
28435: Merged DEV/TEMPORARY to V3.4-BUG-FIX
28428: ALF-9015: cm:modifier not updated when document is updated via CIFS
In ContentDiskDriver.closeFile() added ContentModel.PROP_MODIFIER property update.
28436: ALF-8550: Number of http requests (currentThreadsBusy) increases when session times out during creation of webform
- Corrected use of read and write locks
28465: Fix for ALF-8023 Share preview doesn't work if...
fixed as outlined by Dmitry.
28478: Merged BRANCHES/DEV/ALAN/AUDIT to BRANCHES/DEV/V3.4-BUG-FIX:
28062-28477 (28062,28063,28080,28081,28302,28303,28334,28340,28464,28469,28477) ALF-8438 Need higher level audit of user actions
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@28481 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
461 lines
16 KiB
Java
461 lines
16 KiB
Java
/*
|
|
* Copyright (C) 2005-2010 Alfresco Software Limited.
|
|
*
|
|
* This file is part of Alfresco
|
|
*
|
|
* Alfresco 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Alfresco 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.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
package org.alfresco.repo.avm;
|
|
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
|
|
import org.alfresco.repo.domain.avm.AVMHistoryLinkEntity;
|
|
import org.alfresco.repo.domain.avm.AVMMergeLinkEntity;
|
|
import org.alfresco.repo.domain.permissions.Acl;
|
|
import org.alfresco.repo.lock.JobLockService;
|
|
import org.alfresco.repo.lock.LockAcquisitionException;
|
|
import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
|
|
import org.alfresco.service.cmr.repository.ContentData;
|
|
import org.alfresco.service.namespace.NamespaceService;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.service.transaction.TransactionService;
|
|
import org.apache.commons.logging.Log;
|
|
import org.apache.commons.logging.LogFactory;
|
|
|
|
/**
|
|
* This is the background thread for reaping no longer referenced nodes in the AVM repository. These orphans arise from
|
|
* purge operations.
|
|
*
|
|
* @author britt
|
|
*/
|
|
public class OrphanReaper
|
|
{
|
|
public void execute()
|
|
{
|
|
synchronized (this)
|
|
{
|
|
if (fRunning)
|
|
{
|
|
if (fgLogger.isDebugEnabled())
|
|
{
|
|
fgLogger.debug("OrphanReaper is already running - just return");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
fRunning = true;
|
|
|
|
if (fgLogger.isTraceEnabled())
|
|
{
|
|
fgLogger.trace("Start running OrphanReaper ...");
|
|
}
|
|
}
|
|
try
|
|
{
|
|
do
|
|
{
|
|
doBatch();
|
|
if (fDone)
|
|
{
|
|
if (fgLogger.isTraceEnabled())
|
|
{
|
|
fgLogger.trace("OrphanReaper is done - just return");
|
|
}
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
if (fgLogger.isTraceEnabled())
|
|
{
|
|
fgLogger.trace("OrphanReaper is not done - sleep for "+fActiveBaseSleep+" ms");
|
|
}
|
|
Thread.sleep(fActiveBaseSleep);
|
|
}
|
|
catch (InterruptedException e)
|
|
{
|
|
fgLogger.warn("OrphanReaper was interrupted - do nothing: "+e);
|
|
// Do nothing.
|
|
}
|
|
}
|
|
while (fActive);
|
|
}
|
|
finally
|
|
{
|
|
synchronized (this)
|
|
{
|
|
fRunning = false;
|
|
|
|
if (fgLogger.isTraceEnabled())
|
|
{
|
|
fgLogger.trace("... finish running OrphanReaper");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private Log fgLogger = LogFactory.getLog(OrphanReaper.class);
|
|
|
|
private static final QName LOCK = QName.createQName(NamespaceService.SYSTEM_MODEL_1_0_URI, "OrphanReaper");
|
|
private JobLockService jobLockService;
|
|
|
|
/**
|
|
* The Transaction Service
|
|
*/
|
|
private TransactionService fTransactionService;
|
|
|
|
/**
|
|
* Active base sleep interval.
|
|
*/
|
|
private long fActiveBaseSleep;
|
|
|
|
/**
|
|
* Batch size.
|
|
*/
|
|
private int fBatchSize;
|
|
|
|
/**
|
|
* Whether we are currently active, ie have work queued up.
|
|
*/
|
|
private boolean fActive;
|
|
|
|
private boolean fDone = false;
|
|
|
|
private boolean fRunning = false;
|
|
|
|
/**
|
|
* Create one with default parameters.
|
|
*/
|
|
public OrphanReaper()
|
|
{
|
|
fActiveBaseSleep = 1000;
|
|
fBatchSize = 50;
|
|
fActive = false;
|
|
}
|
|
|
|
// Setters for configuration.
|
|
|
|
/**
|
|
* Set the active base sleep interval.
|
|
*
|
|
* @param interval
|
|
* The interval to set in ms.
|
|
*/
|
|
public void setActiveBaseSleep(long interval)
|
|
{
|
|
fActiveBaseSleep = interval;
|
|
}
|
|
|
|
/**
|
|
* Set the batch size.
|
|
*
|
|
* @param size
|
|
* The batch size to set.
|
|
*/
|
|
public void setBatchSize(int size)
|
|
{
|
|
fBatchSize = size;
|
|
}
|
|
|
|
/**
|
|
* Set the transaction service.
|
|
*
|
|
* @param transactionService
|
|
* The service.
|
|
*/
|
|
public void setTransactionService(TransactionService transactionService)
|
|
{
|
|
fTransactionService = transactionService;
|
|
}
|
|
|
|
/**
|
|
* @param jobLockService service used to ensure that reaper runs are not duplicated
|
|
*/
|
|
public void setJobLockService(JobLockService jobLockService)
|
|
{
|
|
this.jobLockService = jobLockService;
|
|
}
|
|
|
|
/**
|
|
* Start things up after configuration is complete.
|
|
*/
|
|
// public void init()
|
|
// {
|
|
// fThread = new Thread(this);
|
|
// fThread.start();
|
|
// }
|
|
/**
|
|
* Shutdown the reaper. This needs to be called when the application shuts down.
|
|
*/
|
|
public void shutDown()
|
|
{
|
|
fDone = true;
|
|
}
|
|
|
|
/**
|
|
* Attempts to get the lock. If the lock couldn't be taken, then <tt>null</tt> is returned.
|
|
*
|
|
* @return Returns the lock token or <tt>null</tt>
|
|
*/
|
|
private String getLock(long time)
|
|
{
|
|
try
|
|
{
|
|
return jobLockService.getLock(LOCK, time);
|
|
}
|
|
catch (LockAcquisitionException e)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attempts to get the lock. If it fails, the current transaction is marked for rollback.
|
|
*
|
|
* @return Returns the lock token
|
|
*/
|
|
private void refreshLock(String lockToken, long time)
|
|
{
|
|
if (lockToken == null)
|
|
{
|
|
throw new IllegalArgumentException("Must provide existing lockToken");
|
|
}
|
|
jobLockService.refreshLock(lockToken, LOCK, time);
|
|
}
|
|
|
|
|
|
/**
|
|
* Sit in a loop, periodically querying for orphans. When orphans are found, unhook them in bite sized batches.
|
|
*/
|
|
// public void run()
|
|
// {
|
|
// while (!fDone)
|
|
// {
|
|
// synchronized (this)
|
|
// {
|
|
// try
|
|
// {
|
|
// wait(fActive? fActiveBaseSleep : fInactiveBaseSleep);
|
|
// }
|
|
// catch (InterruptedException ie)
|
|
// {
|
|
// // Do nothing.
|
|
// }
|
|
// doBatch();
|
|
// }
|
|
// }
|
|
// }
|
|
/**
|
|
* This is really for debugging and testing. Allows another thread to mark the orphan reaper busy so that it can
|
|
* monitor for it's being done.
|
|
*/
|
|
public void activate()
|
|
{
|
|
fActive = true;
|
|
}
|
|
|
|
/**
|
|
* See if the reaper is actively reaping.
|
|
*
|
|
* @return Whether this is actively reaping.
|
|
*/
|
|
public boolean isActive()
|
|
{
|
|
return fActive;
|
|
}
|
|
|
|
/**
|
|
* Do a batch of cleanup work.
|
|
*/
|
|
public void doBatch()
|
|
{
|
|
class TxnWork implements RetryingTransactionCallback<Object>
|
|
{
|
|
public Object execute() throws Exception
|
|
{
|
|
String lockToken = getLock(20000L);
|
|
if (lockToken == null)
|
|
{
|
|
fgLogger.warn("Can't get lock. Assume multiple reapers ...");
|
|
fActive = false;
|
|
return null;
|
|
}
|
|
|
|
if (fgLogger.isTraceEnabled())
|
|
{
|
|
fgLogger.trace("Orphan reaper doBatch: batchSize="+fBatchSize+", fActiveBaseSleep="+fActiveBaseSleep);
|
|
}
|
|
|
|
refreshLock(lockToken, fBatchSize * 100L);
|
|
List<AVMNode> nodes = AVMDAOs.Instance().fAVMNodeDAO.getOrphans(fBatchSize);
|
|
if (nodes.size() == 0)
|
|
{
|
|
if (fgLogger.isTraceEnabled())
|
|
{
|
|
fgLogger.trace("Nothing to purge (set fActive = false)");
|
|
}
|
|
|
|
fActive = false;
|
|
return null;
|
|
}
|
|
|
|
refreshLock(lockToken, nodes.size() * 100L);
|
|
LinkedList<Long> fPurgeQueue = new LinkedList<Long>();
|
|
for (AVMNode node : nodes)
|
|
{
|
|
fPurgeQueue.add(node.getId());
|
|
}
|
|
|
|
if (fgLogger.isDebugEnabled())
|
|
{
|
|
fgLogger.debug("Queue was empty so got more orphans from DB. Orphan queue size = "+fPurgeQueue.size());
|
|
}
|
|
|
|
fActive = true;
|
|
|
|
int reapCnt = 0;
|
|
|
|
long start = System.currentTimeMillis();
|
|
|
|
for (int i = 0; i < fBatchSize; i++)
|
|
{
|
|
if (fPurgeQueue.size() == 0)
|
|
{
|
|
if (fgLogger.isTraceEnabled())
|
|
{
|
|
fgLogger.trace("Purge queue is empty (fpurgeQueue size = "+fPurgeQueue.size()+")");
|
|
}
|
|
|
|
fPurgeQueue = null;
|
|
break;
|
|
}
|
|
|
|
refreshLock(lockToken, 10000L);
|
|
Long nodeId = fPurgeQueue.removeFirst();
|
|
AVMNode node = AVMDAOs.Instance().fAVMNodeDAO.getByID(nodeId);
|
|
|
|
// Save away the ancestor and merged from fields from this node.
|
|
|
|
AVMNode ancestor = null;
|
|
AVMHistoryLinkEntity hlEntity = AVMDAOs.Instance().newAVMNodeLinksDAO.getHistoryLinkByDescendent(node.getId());
|
|
if (hlEntity != null)
|
|
{
|
|
ancestor = AVMDAOs.Instance().fAVMNodeDAO.getByID(hlEntity.getAncestorNodeId());
|
|
AVMDAOs.Instance().newAVMNodeLinksDAO.deleteHistoryLink(hlEntity.getAncestorNodeId(), hlEntity.getDescendentNodeId());
|
|
}
|
|
|
|
AVMNode mergedFrom = null;
|
|
AVMMergeLinkEntity mlEntity = AVMDAOs.Instance().newAVMNodeLinksDAO.getMergeLinkByTo(node.getId());
|
|
if (mlEntity != null)
|
|
{
|
|
mergedFrom = AVMDAOs.Instance().fAVMNodeDAO.getByID(mlEntity.getMergeFromNodeId());
|
|
AVMDAOs.Instance().newAVMNodeLinksDAO.deleteMergeLink(mlEntity.getMergeFromNodeId(), mlEntity.getMergeToNodeId());
|
|
}
|
|
|
|
// Get all the nodes that have this node as ancestor.
|
|
List<AVMHistoryLinkEntity> hlEntities = AVMDAOs.Instance().newAVMNodeLinksDAO.getHistoryLinksByAncestor(node.getId());
|
|
for (AVMHistoryLinkEntity link : hlEntities)
|
|
{
|
|
AVMNode desc = AVMDAOs.Instance().fAVMNodeDAO.getByID(link.getDescendentNodeId());
|
|
if (desc != null)
|
|
{
|
|
desc.setAncestor(ancestor);
|
|
if (desc.getMergedFrom() == null)
|
|
{
|
|
desc.setMergedFrom(mergedFrom);
|
|
}
|
|
}
|
|
AVMDAOs.Instance().newAVMNodeLinksDAO.deleteHistoryLink(link.getAncestorNodeId(), link.getDescendentNodeId());
|
|
}
|
|
// Get all the nodes that have this node as mergedFrom
|
|
List<AVMMergeLinkEntity> mlEntities = AVMDAOs.Instance().newAVMNodeLinksDAO.getMergeLinksByFrom(node.getId());
|
|
for (AVMMergeLinkEntity link : mlEntities)
|
|
{
|
|
AVMNode mto = AVMDAOs.Instance().fAVMNodeDAO.getByID(link.getMergeToNodeId());
|
|
if (mto != null)
|
|
{
|
|
mto.setMergedFrom(ancestor);
|
|
}
|
|
AVMDAOs.Instance().newAVMNodeLinksDAO.deleteMergeLink(link.getMergeFromNodeId(), link.getMergeToNodeId());
|
|
}
|
|
|
|
// Get rid of all properties belonging to this node.
|
|
AVMDAOs.Instance().fAVMNodeDAO.deleteProperties(node.getId());
|
|
|
|
// Get rid of all aspects belonging to this node.
|
|
AVMDAOs.Instance().fAVMNodeDAO.deleteAspects(node.getId());
|
|
|
|
// Get rid of ACL.
|
|
@SuppressWarnings("unused")
|
|
Acl acl = node.getAcl();
|
|
node.setAcl(null);
|
|
// Unused acls will be garbage collected
|
|
// Many acls will be shared
|
|
// Extra work for directories.
|
|
if (node.getType() == AVMNodeType.PLAIN_DIRECTORY || node.getType() == AVMNodeType.LAYERED_DIRECTORY)
|
|
{
|
|
// First get rid of all child entries for the node.
|
|
AVMDAOs.Instance().fChildEntryDAO.deleteByParent(node);
|
|
}
|
|
else if (node.getType() == AVMNodeType.PLAIN_FILE)
|
|
{
|
|
PlainFileNode file = (PlainFileNode)node;
|
|
if (file.isLegacyContentData())
|
|
{
|
|
// We quickly convert the old ContentData to the new storage
|
|
ContentData contentData = file.getContentData();
|
|
file.setContentData(contentData);
|
|
}
|
|
Long contentDataId = file.getContentDataId();
|
|
if (contentDataId != null)
|
|
{
|
|
// The ContentDataDAO will take care of dereferencing and cleanup
|
|
AVMDAOs.Instance().contentDataDAO.deleteContentData(contentDataId);
|
|
}
|
|
}
|
|
|
|
// Finally, delete it
|
|
AVMDAOs.Instance().fAVMNodeDAO.delete(node);
|
|
|
|
if (fgLogger.isTraceEnabled())
|
|
{
|
|
fgLogger.trace("Deleted Node ["+node.getId()+"]");
|
|
}
|
|
|
|
reapCnt++;
|
|
}
|
|
|
|
if (fgLogger.isDebugEnabled())
|
|
{
|
|
fgLogger.debug("Reaped "+reapCnt+" nodes in "+(System.currentTimeMillis()-start)+" msecs");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
try
|
|
{
|
|
if (!fTransactionService.isReadOnly())
|
|
{
|
|
fTransactionService.getRetryingTransactionHelper().doInTransaction(new TxnWork());
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
fgLogger.error("Garbage collector error", e);
|
|
}
|
|
}
|
|
}
|