Merged HEAD-QA to HEAD (4.2) (including moving test classes into separate folders)

51903 to 54309 


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@54310 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261

source/java/org/alfresco/filesys/repo/LockKeeperImpl.java

@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2013-2013 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/>.
+ * 
+ * @Since 4.2
+ */
+package org.alfresco.filesys.repo;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Date;
+
+import org.alfresco.repo.cache.TransactionalCache;
+import org.alfresco.repo.lock.mem.Lifetime;
+import org.alfresco.repo.security.authentication.AuthenticationUtil;
+import org.alfresco.repo.transaction.RetryingTransactionHelper;
+import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
+import org.alfresco.service.cmr.lock.LockService;
+import org.alfresco.service.cmr.lock.LockStatus;
+import org.alfresco.service.cmr.lock.LockType;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.alfresco.service.transaction.TransactionService;
+import org.alfresco.util.PropertyCheck;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * AlfrescoLockKeeperImpl
+ * <p>
+ * Repository level locking for CIFS, prevents files open via CIFS/FTP/JLAN being interfered with by the alfresco "back end".
+ * 
+ * Delegates ephemeral locking requests to the lockService.
+ * 
+ * @author mrogers
+ *
+ */
+public class LockKeeperImpl implements LockKeeper 
+{
+	private String LOCK_KEEPER_KEY = "AlfrescoLockKeeperImpl";
+	
+	private LockService lockService;
+	private TransactionService transactionService;
+	
+    private TransactionalCache<NodeRef, KeeperInfo> lockKeeperTransactionalCache;
+	
+	private int timeToExpire = 3600 * 2;  // 2 Hours
+	private boolean lockEnabled = true;
+	
+    private static final Log logger = LogFactory.getLog(LockKeeperImpl.class);
+    
+    public void init()
+    {
+        PropertyCheck.mandatory(this, "lockService", getLockService());
+        PropertyCheck.mandatory(this, "lockKeeperTransactionalCache", getLockKeeperTransactionalCache());
+        PropertyCheck.mandatory(this, "transactionService", getTransactionService());
+    }
+ 
+
+	@Override
+	public void addLock(NodeRef nodeRef) 
+	{
+		if(lockEnabled)
+		{
+			if(logger.isDebugEnabled())
+			{
+				logger.debug("lock nodeRef:" + nodeRef);
+			}
+		    getLockService().lock(nodeRef, LockType.WRITE_LOCK, getTimeToExpire(), Lifetime.EPHEMERAL, LOCK_KEEPER_KEY);
+		    lockKeeperTransactionalCache.put(nodeRef, new KeeperInfo(AuthenticationUtil.getFullyAuthenticatedUser()));
+		}
+	}
+
+	@Override
+	public void removeLock(NodeRef nodeRef) 
+	{
+		if(lockEnabled)
+		{
+		    logger.trace("removeLock nodeRef:" + nodeRef);
+		    getLockService().unlock(nodeRef);
+		    lockKeeperTransactionalCache.remove(nodeRef);
+		}
+	}
+
+	@Override
+	public void refreshAllLocks() 
+	{
+		Collection<NodeRef> nodes = lockKeeperTransactionalCache.getKeys();
+		if(logger.isTraceEnabled())
+		{
+		    logger.trace("RefreshAllLocks called for #locks, " + nodes.size());
+		}
+		
+		if(!transactionService.getAllowWrite())
+		{
+			if(logger.isTraceEnabled())
+			{
+			    logger.trace("Repo is read only - do nothing");
+			    return;
+			}
+		}
+		for(NodeRef nodeRef : nodes)
+		{
+			final NodeRef nodeRefToRefresh = nodeRef;
+			final KeeperInfo keeperInfo = lockKeeperTransactionalCache.get(nodeRefToRefresh);
+			final String additionalInfo = lockService.getAdditionalInfo(nodeRefToRefresh);
+			
+		    transactionService.getRetryingTransactionHelper().doInTransaction(
+			new RetryingTransactionCallback<Void>()
+			{	
+			    @Override
+        	    public Void execute() throws Throwable 
+			    {
+					if(LOCK_KEEPER_KEY.equalsIgnoreCase(additionalInfo))
+					{
+						// Its one of this class's locks
+					    AuthenticationUtil.setFullyAuthenticatedUser(keeperInfo.getOwner());
+				
+					    //TODO What about node does not exist?
+			    	    switch (lockService.getLockStatus(nodeRefToRefresh))
+			    	    {
+			    	        case LOCK_OWNER:
+			    	        	if(logger.isDebugEnabled())
+			    	        	{
+			    	        	logger.debug("refresh ephemeral lock nodeRef: " + nodeRefToRefresh);
+			    	        	}
+			    	        	// Expect to go here - refresh the lock
+			    	            getLockService().lock(nodeRefToRefresh, LockType.WRITE_LOCK, getTimeToExpire(), Lifetime.EPHEMERAL, LOCK_KEEPER_KEY);
+			    	            break;
+			    	        case LOCKED:
+			    	        	// Locked by somebody else? Something has gone wrong here
+			    	        case LOCK_EXPIRED:
+			    	        default:
+			    	        	if(logger.isDebugEnabled())
+			    	        	{
+			    	        	    logger.debug("remove lock from lock keeper cache, nodeRef: " + nodeRefToRefresh);
+			    	        	}
+			    	        	lockKeeperTransactionalCache.remove(nodeRefToRefresh);
+			    	    }
+					}
+					else
+					{
+	    	        	if(logger.isDebugEnabled())
+	    	        	{
+	    	        	    logger.debug("not a lock keeper lock, remove lock from lock keeper cache, nodeRef: " + nodeRefToRefresh);
+	    	        	}
+						lockKeeperTransactionalCache.remove(nodeRefToRefresh);
+					}
+			    	return null;
+			    }
+						
+			}, false, true);
+		}
+	}
+
+	public void setLockEnabled(boolean lockEnabled) {
+		this.lockEnabled = lockEnabled;
+	}
+
+	public boolean isLockEnabled() {
+		return lockEnabled;
+	}
+
+
+	public void setLockService(LockService lockService) {
+		this.lockService = lockService;
+	}
+
+
+	public LockService getLockService() {
+		return lockService;
+	}
+
+
+	public void setLockKeeperTransactionalCache(
+			TransactionalCache<NodeRef, KeeperInfo> lockKeeperTransactionalCache) 
+	{
+		this.lockKeeperTransactionalCache = lockKeeperTransactionalCache;
+	}
+
+
+	public TransactionalCache<NodeRef, KeeperInfo> getLockKeeperTransactionalCache() 
+	{
+		return lockKeeperTransactionalCache;
+	}
+
+
+	public void setTransactionService(TransactionService transactionHelper) 
+	{
+		this.transactionService = transactionHelper;
+	}
+
+
+	public TransactionService getTransactionService() 
+	{
+		return transactionService;
+	}
+	
+	public void setTimeToExpire(int timeToExpire) {
+		this.timeToExpire = timeToExpire;
+	}
+
+
+	public int getTimeToExpire() {
+		return timeToExpire;
+	}
+
+	private class KeeperInfo implements Serializable
+	{
+		/**
+		 * 
+		 */
+		private static final long serialVersionUID = -4200553975218699638L;
+		/**
+		 * 
+		 */
+		KeeperInfo(String owner)
+		{
+		    this.setOwner(owner);
+		    lockTime = new Date();
+		}
+		public void setOwner(String owner) {
+			this.owner = owner;
+		}
+		public String getOwner() {
+			return owner;
+		}
+		private String owner;
+		Date lockTime;
+	}
+
+}