[exo-jcr-commits] exo-jcr SVN: r2806 - in jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr: impl/core/lock/jbosscache and 1 other directories.

Wednesday, 21 July 2010


Author: tolusha
Date: 2010-07-21 04:00:15 -0400 (Wed, 21 Jul 2010)
New Revision: 2806

Added:
  
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/jbosscache/AbstractCacheableLockManagerImpl.java
Modified:
  
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/infinispan/InfinispanLockManagerImpl.java
  
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/infinispan/InfinispanCacheFactory.java
Log:
EXOJCR-831: add abstract class AbstractCacheableLockManagerImpl

Modified:
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/infinispan/InfinispanLockManagerImpl.java
===================================================================
---
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/infinispan/InfinispanLockManagerImpl.java	2010-07-20
15:58:02 UTC (rev 2805)
+++
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/infinispan/InfinispanLockManagerImpl.java	2010-07-21
08:00:15 UTC (rev 2806)
@@ -19,89 +19,52 @@
 
 import org.exoplatform.container.configuration.ConfigurationManager;
 import org.exoplatform.management.annotations.Managed;
-import org.exoplatform.management.annotations.ManagedDescription;
 import org.exoplatform.management.jmx.annotations.NameTemplate;
 import org.exoplatform.management.jmx.annotations.Property;
 import org.exoplatform.services.jcr.config.MappedParametrizedObjectEntry;
 import org.exoplatform.services.jcr.config.RepositoryConfigurationException;
 import org.exoplatform.services.jcr.config.WorkspaceEntry;
-import org.exoplatform.services.jcr.dataflow.ChangesLogIterator;
-import org.exoplatform.services.jcr.dataflow.CompositeChangesLog;
-import org.exoplatform.services.jcr.dataflow.DataManager;
-import org.exoplatform.services.jcr.dataflow.ItemState;
-import org.exoplatform.services.jcr.dataflow.ItemStateChangesLog;
-import org.exoplatform.services.jcr.dataflow.PlainChangesLog;
-import org.exoplatform.services.jcr.dataflow.PlainChangesLogImpl;
-import org.exoplatform.services.jcr.dataflow.TransactionChangesLog;
-import org.exoplatform.services.jcr.dataflow.persistent.ItemsPersistenceListener;
-import org.exoplatform.services.jcr.datamodel.ItemData;
-import org.exoplatform.services.jcr.datamodel.NodeData;
-import org.exoplatform.services.jcr.datamodel.PropertyData;
-import org.exoplatform.services.jcr.datamodel.QPathEntry;
-import org.exoplatform.services.jcr.impl.Constants;
-import org.exoplatform.services.jcr.impl.core.SessionDataManager;
-import org.exoplatform.services.jcr.impl.core.lock.LockRemover;
-import org.exoplatform.services.jcr.impl.core.lock.SessionLockManager;
-import org.exoplatform.services.jcr.impl.core.lock.jbosscache.CacheableLockManager;
+import
org.exoplatform.services.jcr.impl.core.lock.jbosscache.AbstractCacheableLockManagerImpl;
 import
org.exoplatform.services.jcr.impl.core.lock.jbosscache.CacheableSessionLockManager;
 import org.exoplatform.services.jcr.impl.core.lock.jbosscache.LockData;
-import org.exoplatform.services.jcr.impl.dataflow.TransientItemData;
-import org.exoplatform.services.jcr.impl.dataflow.TransientPropertyData;
 import
org.exoplatform.services.jcr.impl.dataflow.persistent.WorkspacePersistentDataManager;
-import org.exoplatform.services.jcr.impl.storage.JCRInvalidItemStateException;
 import org.exoplatform.services.jcr.impl.storage.jdbc.DBConstants;
 import org.exoplatform.services.jcr.impl.storage.jdbc.DialectDetecter;
 import org.exoplatform.services.jcr.impl.util.io.PrivilegedCacheHelper;
 import org.exoplatform.services.jcr.infinispan.InfinispanCacheFactory;
-import org.exoplatform.services.jcr.observation.ExtendedEvent;
 import org.exoplatform.services.log.ExoLogger;
 import org.exoplatform.services.log.Log;
 import org.exoplatform.services.naming.InitialContextInitializer;
-import org.exoplatform.services.security.IdentityConstants;
 import org.exoplatform.services.transaction.TransactionService;
 import org.infinispan.Cache;
-import org.picocontainer.Startable;
 
 import java.io.Serializable;
-import java.math.BigInteger;
 import java.security.AccessController;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
 import java.security.PrivilegedActionException;
 import java.security.PrivilegedExceptionAction;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 
 import javax.jcr.RepositoryException;
 import javax.jcr.lock.LockException;
 import javax.naming.InitialContext;
 import javax.sql.DataSource;
-import javax.transaction.Transaction;
-import javax.transaction.TransactionManager;
+import javax.transaction.Transaction 
 
 /**
  * @author <a href=&quot;anatoliy.bazko(a)exoplatform.org&quot;&gt;Anatoliy
Bazko</a>
- * @version $Id: InfinispanLockManagerImpl.java 111 2010-11-11 11:11:11Z tolusha $
+ * @version $Id$
  *
  */
 @Managed
 @NameTemplate(@Property(key = "service", value = "lockmanager"))
-public class InfinispanLockManagerImpl implements CacheableLockManager,
ItemsPersistenceListener, Startable
+public class InfinispanLockManagerImpl extends AbstractCacheableLockManagerImpl
 {
 
    /**
-    *  The name to property time out.  
-    */
-   public static final String TIME_OUT = "time-out";
-
-   /**
     *  The name to property cache configuration. 
     */
    public static final String INFINISPAN_JDBC_CL_DATASOURCE =
"infinispan-cl-cache.jdbc.datasource";
@@ -115,44 +78,12 @@
    public static final String INFINISPAN_JDBC_CL_AUTO = "auto";
 
    /**
-    * Default lock time out. 30min
-    */
-   public static final long DEFAULT_LOCK_TIMEOUT = 1000 * 60 * 30;
-
-   /**
     * Logger
     */
    private final Log LOG =
ExoLogger.getLogger("exo.jcr.component.core.InfinispanLockManagerImpl");
 
-   /**
-    * Data manager.
-    */
-   private final DataManager dataManager;
-
-   /**
-    * Run time lock time out.
-    */
-   private long lockTimeOut;
-
-   /**
-    * Lock remover thread.
-    */
-   private LockRemover lockRemover;
-
-   /**
-    * The current Transaction Manager
-    */
-   private TransactionManager tm;
-
    private Cache<Serializable, Object> cache;
 
-   //   private final Fqn<String> lockRoot;
-
-   /**
-    * SessionLockManagers that uses this LockManager.
-    */
-   private Map<String, CacheableSessionLockManager> sessionLockManagers;
-
    public InfinispanLockManagerImpl(WorkspacePersistentDataManager dataManager,
WorkspaceEntry config,
       InitialContextInitializer context, TransactionService transactionService,
ConfigurationManager cfm)
       throws RepositoryConfigurationException, RepositoryException
@@ -171,35 +102,11 @@
       InitialContextInitializer context, TransactionManager transactionManager,
ConfigurationManager cfm)
       throws RepositoryConfigurationException, RepositoryException
    {
-      this.dataManager = dataManager;
+      super(dataManager, config, transactionManager);
 
-      if (config.getLockManager() != null)
-      {
-         if (config.getLockManager().getParameters() != null
-            && config.getLockManager().getParameterValue(TIME_OUT, null) !=
null)
-         {
-            long timeOut = config.getLockManager().getParameterTime(TIME_OUT);
-            lockTimeOut = timeOut > 0 ? timeOut : DEFAULT_LOCK_TIMEOUT;
-         }
-         else
-         {
-            lockTimeOut =
-               config.getLockManager().getTimeout() > 0 ?
config.getLockManager().getTimeout() : DEFAULT_LOCK_TIMEOUT;
-         }
-      }
-      else
-      {
-         lockTimeOut = DEFAULT_LOCK_TIMEOUT;
-      }
-
-      sessionLockManagers = new ConcurrentHashMap<String,
CacheableSessionLockManager>();
-      dataManager.addItemPersistenceListener(this);
-
       // make cache
       if (config.getLockManager() != null)
       {
-         this.tm = transactionManager;
-
          // create cache using custom factory
          InfinispanCacheFactory<Serializable, Object> factory = new
InfinispanCacheFactory<Serializable, Object>(cfm);
 
@@ -218,6 +125,83 @@
       {
          throw new RepositoryConfigurationException("Cache configuration not
found");
       }
+
+      this.getNumLocks = new LockActionNonTxAware<Integer, Object>()
+      {
+         public Integer execute(Object arg)
+         {
+            return cache.size();
+         }
+      };
+
+      this.hasLocks = new LockActionNonTxAware<Boolean, Object>()
+      {
+         public Boolean execute(Object arg)
+         {
+            return !cache.isEmpty();
+         }
+      };
+
+      this.isLockLive = new LockActionNonTxAware<Boolean, String>()
+      {
+         public Boolean execute(String nodeId)
+         {
+            if (cache.get(nodeId) != null)
+            {
+               return true;
+            }
+
+            return false;
+         }
+      };
+
+      this.refresh = new LockActionNonTxAware<Object, LockData>()
+      {
+         public Object execute(LockData newLockData) throws LockException
+         {
+            Object oldValue = PrivilegedCacheHelper.putIfAbsent(cache,
newLockData.getNodeIdentifier(), newLockData);
+            if (oldValue == null)
+            {
+               throw new LockException("Can't refresh lock for node " +
newLockData.getNodeIdentifier()
+                  + " since lock is not exist");
+            }
+            return null;
+         }
+      };
+
+      this.lockExist = new LockActionNonTxAware<Boolean, String>()
+      {
+         public Boolean execute(String nodeId) throws LockException
+         {
+            return cache.get(nodeId) != null;
+         }
+      };
+
+      this.getLockDataById = new LockActionNonTxAware<LockData, String>()
+      {
+         public LockData execute(String nodeId) throws LockException
+         {
+            return (LockData)cache.get(nodeId);
+         }
+      };
+
+      this.getLockList = new LockActionNonTxAware<List<LockData>, Object>()
+      {
+         public List<LockData> execute(Object arg) throws LockException
+         {
+            Collection<Object> datas = cache.values();
+
+            List<LockData> locksData = new ArrayList<LockData>();
+            for (Object lockData : datas)
+            {
+               if (lockData != null)
+               {
+                  locksData.add((LockData)lockData);
+               }
+            }
+            return locksData;
+         }
+      };
    }
 
    /**
@@ -365,388 +349,23 @@
       }
    }
 
-   @Managed
-   @ManagedDescription("Remove the expired locks")
-   public void cleanExpiredLocks()
-   {
-      removeExpired();
-   }
-
-   public long getDefaultLockTimeOut()
-   {
-      return lockTimeOut;
-   }
-
-   private final LockActionNonTxAware<Integer, Object> getNumLocks = new
LockActionNonTxAware<Integer, Object>()
-   {
-      public Integer execute(Object arg)
-      {
-         return cache.size();
-      }
-   };
-
-   @Managed
-   @ManagedDescription("The number of active locks")
-   public int getNumLocks()
-   {
-      try
-      {
-         return executeLockActionNonTxAware(getNumLocks, null);
-      }
-      catch (LockException e)
-      {
-         // ignore me will never occur
-      }
-      return -1;
-   }
-
-   private final LockActionNonTxAware<Boolean, Object> hasLocks = new
LockActionNonTxAware<Boolean, Object>()
-   {
-      public Boolean execute(Object arg)
-      {
-         return !cache.isEmpty();
-      }
-   };
-
    /**
-    * Indicates if some locks have already been created
-    */
-   private boolean hasLocks()
-   {
-      try
-      {
-         return executeLockActionNonTxAware(hasLocks, null);
-      }
-      catch (LockException e)
-      {
-         // ignore me will never occur
-      }
-      return true;
-   }
-
-   /**
-    * Return new instance of session lock manager.
-    */
-   public SessionLockManager getSessionLockManager(String sessionId, SessionDataManager
transientManager)
-   {
-      CacheableSessionLockManager sessionManager = new
CacheableSessionLockManager(sessionId, this, transientManager);
-      sessionLockManagers.put(sessionId, sessionManager);
-      return sessionManager;
-   }
-
-   private final LockActionNonTxAware<Boolean, String> isLockLive = new
LockActionNonTxAware<Boolean, String>()
-   {
-      public Boolean execute(String nodeId)
-      {
-         if (cache.get(nodeId) != null) //pendingLocks.containsKey(nodeId) || 
-         {
-            return true;
-         }
-
-         return false;
-      }
-   };
-
-   /**
-    * Check is LockManager contains lock. No matter it is in pending or persistent
state.
-    * 
-    * @param nodeId - locked node id
-    * @return 
-    */
-   public boolean isLockLive(String nodeId) throws LockException
-   {
-      try
-      {
-         return executeLockActionNonTxAware(isLockLive, nodeId);
-      }
-      catch (LockException e)
-      {
-         // ignore me will never occur
-      }
-      return false;
-   }
-
-   /**
     * {@inheritDoc}
     */
-   public boolean isTXAware()
-   {
-      return true;
-   }
-
-   /*
-    * (non-Javadoc)
-    *
@seeorg.exoplatform.services.jcr.dataflow.persistent.ItemsPersistenceListener#onSaveItems(org.
-    * exoplatform.services.jcr.dataflow.ItemStateChangesLog)
-    */
-   public void onSaveItems(ItemStateChangesLog changesLog)
-   {
-      List<PlainChangesLog> chengesLogList = new
ArrayList<PlainChangesLog>();
-      if (changesLog instanceof TransactionChangesLog)
-      {
-         ChangesLogIterator logIterator =
((TransactionChangesLog)changesLog).getLogIterator();
-
-         while (logIterator.hasNextLog())
-         {
-            chengesLogList.add(logIterator.nextLog());
-         }
-      }
-      else if (changesLog instanceof PlainChangesLog)
-      {
-         chengesLogList.add((PlainChangesLog)changesLog);
-      }
-      else if (changesLog instanceof CompositeChangesLog)
-      {
-         for (ChangesLogIterator iter =
((CompositeChangesLog)changesLog).getLogIterator(); iter.hasNextLog();)
-         {
-            chengesLogList.add(iter.nextLog());
-         }
-      }
-
-      List<LockOperationContainer> containers = new
ArrayList<LockOperationContainer>();
-
-      for (PlainChangesLog currChangesLog : chengesLogList)
-      {
-         String sessionId = currChangesLog.getSessionId();
-
-         String nodeIdentifier;
-         try
-         {
-            switch (currChangesLog.getEventType())
-            {
-               case ExtendedEvent.LOCK :
-                  if (currChangesLog.getSize() < 2)
-                  {
-                     LOG.error("Incorrect changes log  of type ExtendedEvent.LOCK
size=" + currChangesLog.getSize()
-                        + "<2 \n" + currChangesLog.dump());
-                     break;
-                  }
-                  nodeIdentifier =
currChangesLog.getAllStates().get(0).getData().getParentIdentifier();
-
-                  CacheableSessionLockManager session =
sessionLockManagers.get(sessionId);
-                  if (session != null &&
session.containsPendingLock(nodeIdentifier))
-                  {
-                     containers.add(new LockOperationContainer(nodeIdentifier,
currChangesLog.getSessionId(),
-                        ExtendedEvent.LOCK));
-                  }
-                  else
-                  {
-                     LOG.error("Lock must exist in pending locks.");
-                  }
-                  break;
-               case ExtendedEvent.UNLOCK :
-                  if (currChangesLog.getSize() < 2)
-                  {
-                     LOG.error("Incorrect changes log  of type ExtendedEvent.UNLOCK
size=" + currChangesLog.getSize()
-                        + "<2 \n" + currChangesLog.dump());
-                     break;
-                  }
-
-                  containers.add(new
LockOperationContainer(currChangesLog.getAllStates().get(0).getData()
-                     .getParentIdentifier(), currChangesLog.getSessionId(),
ExtendedEvent.UNLOCK));
-                  break;
-               default :
-                  HashSet<String> removedLock = new HashSet<String>();
-                  for (ItemState itemState : currChangesLog.getAllStates())
-                  {
-                     // this is a node and node is locked
-                     if (itemState.getData().isNode() &&
lockExist(itemState.getData().getIdentifier()))
-                     {
-                        nodeIdentifier = itemState.getData().getIdentifier();
-                        if (itemState.isDeleted())
-                        {
-                           removedLock.add(nodeIdentifier);
-                        }
-                        else if (itemState.isAdded() || itemState.isRenamed() ||
itemState.isUpdated())
-                        {
-                           removedLock.remove(nodeIdentifier);
-                        }
-                     }
-                  }
-                  for (String identifier : removedLock)
-                  {
-                     containers.add(new LockOperationContainer(identifier,
currChangesLog.getSessionId(),
-                        ExtendedEvent.UNLOCK));
-                  }
-                  break;
-            }
-         }
-         catch (IllegalStateException e)
-         {
-            LOG.error(e.getLocalizedMessage(), e);
-         }
-      }
-
-      // sort locking and unlocking operations to avoid deadlocks in Infinispan
-      Collections.sort(containers);
-      for (LockOperationContainer container : containers)
-      {
-         try
-         {
-            container.apply();
-         }
-         catch (LockException e)
-         {
-            LOG.error(e.getMessage(), e);
-         }
-      }
-   }
-
-   /**
-    * Class containing operation type (LOCK or UNLOCK) and all the needed information
like node uuid and session id.
-    */
-   private class LockOperationContainer implements
Comparable<LockOperationContainer>
-   {
-
-      private String identifier;
-
-      private String sessionId;
-
-      private int type;
-
-      /**
-       * @param identifier node identifier 
-       * @param sessionId id of session
-       * @param type ExtendedEvent type specifying the operation (LOCK or UNLOCK)
-       */
-      public LockOperationContainer(String identifier, String sessionId, int type)
-      {
-         super();
-         this.identifier = identifier;
-         this.sessionId = sessionId;
-         this.type = type;
-      }
-
-      /**
-       * @return node identifier
-       */
-      public String getIdentifier()
-      {
-         return identifier;
-      }
-
-      public void apply() throws LockException
-      {
-         // invoke internalLock in LOCK operation
-         if (type == ExtendedEvent.LOCK)
-         {
-            internalLock(sessionId, identifier);
-         }
-         // invoke internalUnLock in UNLOCK operation
-         else if (type == ExtendedEvent.UNLOCK)
-         {
-            internalUnLock(sessionId, identifier);
-         }
-      }
-
-      /**
-       * @see java.lang.Comparable#compareTo(java.lang.Object)
-       */
-      public int compareTo(LockOperationContainer o)
-      {
-         return identifier.compareTo(o.getIdentifier());
-      }
-   }
-
-   private final LockActionNonTxAware<Object, LockData> refresh = new
LockActionNonTxAware<Object, LockData>()
-   {
-      public Object execute(LockData newLockData) throws LockException
-      {
-         Object oldValue = PrivilegedCacheHelper.putIfAbsent(cache,
newLockData.getNodeIdentifier(), newLockData);
-         if (oldValue == null)
-         {
-            throw new LockException("Can't refresh lock for node " +
newLockData.getNodeIdentifier()
-               + " since lock is not exist");
-         }
-         return null;
-      }
-   };
-
-   /**
-    * Refreshed lock data in cache
-    * 
-    * @param newLockData
-    */
-   public void refreshLockData(LockData newLockData) throws LockException
-   {
-      executeLockActionNonTxAware(refresh, newLockData);
-   }
-
-   /**
-    * Remove expired locks. Used from LockRemover.
-    */
-   public synchronized void removeExpired()
-   {
-      final List<String> removeLockList = new ArrayList<String>();
-
-      for (LockData lock : getLockList())
-      {
-         if (!lock.isSessionScoped() && lock.getTimeToDeath() < 0)
-         {
-            removeLockList.add(lock.getNodeIdentifier());
-         }
-      }
-
-      Collections.sort(removeLockList);
-
-      for (String rLock : removeLockList)
-      {
-         removeLock(rLock);
-      }
-   }
-
-   /*
-    * (non-Javadoc)
-    * @see org.picocontainer.Startable#start()
-    */
-   public void start()
-   {
-      lockRemover = new LockRemover(this);
-   }
-
-   /*
-    * (non-Javadoc)
-    * @see org.picocontainer.Startable#stop()
-    */
+   @Override
    public void stop()
    {
-      lockRemover.halt();
-      lockRemover.interrupt();
-      sessionLockManagers.clear();
+      super.stop();
 
       PrivilegedCacheHelper.stop(cache);
    }
 
    /**
-    * Copy <code>PropertyData prop<code> to new TransientItemData
-    * 
-    * @param prop
-    * @return
-    * @throws RepositoryException
+    * {@inheritDoc}
     */
-   private TransientItemData copyItemData(PropertyData prop) throws RepositoryException
+   @Override
+   protected synchronized void internalLock(String sessionId, String nodeIdentifier)
throws LockException
    {
-      if (prop == null)
-      {
-         return null;
-      }
-
-      // make a copy, value may be null for deleting items
-      TransientPropertyData newData =
-         new TransientPropertyData(prop.getQPath(), prop.getIdentifier(),
prop.getPersistedVersion(), prop.getType(),
-            prop.getParentIdentifier(), prop.isMultiValued(), prop.getValues());
-
-      return newData;
-   }
-
-   /**
-    * Internal lock
-    * 
-    * @param nodeIdentifier
-    * @throws LockException
-    */
-   private synchronized void internalLock(String sessionId, String nodeIdentifier) throws
LockException
-   {
       CacheableSessionLockManager session = sessionLockManagers.get(sessionId);
       if (session != null && session.containsPendingLock(nodeIdentifier))
       {
@@ -770,13 +389,10 @@
    }
 
    /**
-    * Internal unlock.
-    * 
-    * @param sessionId
-    * @param nodeIdentifier
-    * @throws LockException
+    * {@inheritDoc}
     */
-   private synchronized void internalUnLock(String sessionId, String nodeIdentifier)
throws LockException
+   @Override
+   protected synchronized void internalUnLock(String sessionId, String nodeIdentifier)
throws LockException
    {
       LockData lData = getLockDataById(nodeIdentifier);
 
@@ -791,306 +407,4 @@
          }
       }
    }
-
-   private final LockActionNonTxAware<Boolean, String> lockExist = new
LockActionNonTxAware<Boolean, String>()
-   {
-      public Boolean execute(String nodeId) throws LockException
-      {
-         return cache.get(nodeId) != null;
-      }
-   };
-
-   /**
-    * {@inheritDoc}
-    */
-   public boolean lockExist(String nodeId)
-   {
-      try
-      {
-         return executeLockActionNonTxAware(lockExist, nodeId);
-      }
-      catch (LockException e)
-      {
-         // ignore me will never occur
-      }
-      return false;
-   }
-
-   /**
-    * {@inheritDoc}
-    */
-   public String getLockTokenHash(String token)
-   {
-      String hash = "";
-      try
-      {
-         MessageDigest m = MessageDigest.getInstance("MD5");
-         m.update(token.getBytes(), 0, token.length());
-         hash = new BigInteger(1, m.digest()).toString(16);
-      }
-      catch (NoSuchAlgorithmException e)
-      {
-         LOG.error("Can't get instanse of MD5 MessageDigest!", e);
-      }
-      return hash;
-   }
-
-   /**
-    * {@inheritDoc}
-    */
-   public LockData getExactNodeOrCloseParentLock(NodeData node) throws
RepositoryException
-   {
-      return getExactNodeOrCloseParentLock(node, true);
-   }
-
-   private LockData getExactNodeOrCloseParentLock(NodeData node, boolean checkHasLocks)
throws RepositoryException
-   {
-
-      if (node == null || (checkHasLocks && !hasLocks()))
-      {
-         return null;
-      }
-      LockData retval = null;
-      retval = getLockDataById(node.getIdentifier());
-      if (retval == null)
-      {
-         NodeData parentData =
(NodeData)dataManager.getItemData(node.getParentIdentifier());
-         if (parentData != null)
-         {
-            retval = getExactNodeOrCloseParentLock(parentData, false);
-         }
-      }
-      return retval;
-   }
-
-   /**
-    * {@inheritDoc}
-    */
-   public LockData getExactNodeLock(NodeData node) throws RepositoryException
-   {
-      if (node == null || !hasLocks())
-      {
-         return null;
-      }
-
-      return getLockDataById(node.getIdentifier());
-   }
-
-   /**
-    * {@inheritDoc}
-    */
-   public LockData getClosedChild(NodeData node) throws RepositoryException
-   {
-      return getClosedChild(node, true);
-   }
-
-   private LockData getClosedChild(NodeData node, boolean checkHasLocks) throws
RepositoryException
-   {
-
-      if (node == null || (checkHasLocks && !hasLocks()))
-      {
-         return null;
-      }
-      LockData retval = null;
-
-      List<NodeData> childData = dataManager.getChildNodesData(node);
-      for (NodeData nodeData : childData)
-      {
-         retval = getLockDataById(nodeData.getIdentifier());
-         if (retval != null)
-            return retval;
-      }
-      // child not found try to find dipper
-      for (NodeData nodeData : childData)
-      {
-         retval = getClosedChild(nodeData, false);
-         if (retval != null)
-            return retval;
-      }
-      return retval;
-   }
-
-   private final LockActionNonTxAware<LockData, String> getLockDataById = new
LockActionNonTxAware<LockData, String>()
-   {
-      public LockData execute(String nodeId) throws LockException
-      {
-         return (LockData)cache.get(nodeId);
-      }
-   };
-
-   protected LockData getLockDataById(String nodeId)
-   {
-      try
-      {
-         return executeLockActionNonTxAware(getLockDataById, nodeId);
-      }
-      catch (LockException e)
-      {
-         // ignore me will never occur
-      }
-      return null;
-   }
-
-   private final LockActionNonTxAware<List<LockData>, Object> getLockList =
-      new LockActionNonTxAware<List<LockData>, Object>()
-      {
-         public List<LockData> execute(Object arg) throws LockException
-         {
-            Collection<Object> datas = cache.values();
-
-            List<LockData> locksData = new ArrayList<LockData>();
-            for (Object lockData : datas)
-            {
-               if (lockData != null)
-               {
-                  locksData.add((LockData)lockData);
-               }
-            }
-            return locksData;
-         }
-      };
-
-   protected synchronized List<LockData> getLockList()
-   {
-      try
-      {
-         return executeLockActionNonTxAware(getLockList, null);
-      }
-      catch (LockException e)
-      {
-         // ignore me will never occur
-      }
-      return null;
-   }
-
-   /**
-    * Remove lock, used by Lock remover.
-    * 
-    * @param nodeIdentifier String
-    */
-   protected void removeLock(String nodeIdentifier)
-   {
-      try
-      {
-         NodeData nData = (NodeData)dataManager.getItemData(nodeIdentifier);
-
-         //TODO EXOJCR-412, should be refactored in future.
-         //Skip removing, because that node was removed in other node of cluster.  
-         if (nData == null)
-         {
-            return;
-         }
-
-         PlainChangesLog changesLog =
-            new PlainChangesLogImpl(new ArrayList<ItemState>(),
IdentityConstants.SYSTEM, ExtendedEvent.UNLOCK);
-
-         ItemData lockOwner =
-            copyItemData((PropertyData)dataManager.getItemData(nData, new
QPathEntry(Constants.JCR_LOCKOWNER, 1)));
-
-         //TODO EXOJCR-412, should be refactored in future.
-         //Skip removing, because that lock was removed in other node of cluster.  
-         if (lockOwner == null)
-         {
-            return;
-         }
-
-         changesLog.add(ItemState.createDeletedState(lockOwner));
-
-         ItemData lockIsDeep =
-            copyItemData((PropertyData)dataManager.getItemData(nData, new
QPathEntry(Constants.JCR_LOCKISDEEP, 1)));
-
-         //TODO EXOJCR-412, should be refactored in future.
-         //Skip removing, because that lock was removed in other node of cluster.  
-         if (lockIsDeep == null)
-         {
-            return;
-         }
-
-         changesLog.add(ItemState.createDeletedState(lockIsDeep));
-
-         // lock probably removed by other thread
-         if (lockOwner == null && lockIsDeep == null)
-         {
-            return;
-         }
-
-         dataManager.save(new TransactionChangesLog(changesLog));
-      }
-      catch (JCRInvalidItemStateException e)
-      {
-         //TODO EXOJCR-412, should be refactored in future.
-         //Skip property not found in DB, because that lock property was removed in other
node of cluster.
-         if (LOG.isDebugEnabled())
-         {
-            LOG.debug("The propperty was removed in other node of cluster.",
e);
-         }
-
-      }
-      catch (RepositoryException e)
-      {
-         LOG.error("Error occur during removing lock" +
e.getLocalizedMessage(), e);
-      }
-   }
-
-   /**
-    * {@inheritDoc}
-    */
-   public void closeSessionLockManager(String sessionID)
-   {
-      sessionLockManagers.remove(sessionID);
-   }
-
-   /**
-    * Execute the given action outside a transaction. This is needed since the {@link
Cache} used by {@link InfinispanLockManagerImpl}
-    * manages the persistence of its locks thanks to a {@link CacheLoader} and a {@link
CacheLoader} lock the Infinispan cache {@link Node}
-    * even for read operations which cause deadlock issue when a XA {@link Transaction}
is already opened
-    * @throws LockException when a exception occurs
-    */
-   private <R, A> R executeLockActionNonTxAware(LockActionNonTxAware<R, A>
action, A arg) throws LockException
-   {
-      Transaction tx = null;
-      try
-      {
-         if (tm != null)
-         {
-            try
-            {
-               tx = tm.suspend();
-            }
-            catch (Exception e)
-            {
-               LOG.warn("Cannot suspend the current transaction", e);
-            }
-         }
-         return action.execute(arg);
-      }
-      finally
-      {
-         if (tx != null)
-         {
-            try
-            {
-               tm.resume(tx);
-            }
-            catch (Exception e)
-            {
-               LOG.warn("Cannot resume the current transaction", e);
-            }
-         }
-      }
-   }
-
-   /**
-    * Actions that are not supposed to be called within a transaction
-    * 
-    * Created by The eXo Platform SAS
-    * Author : Nicolas Filotto 
-    *          nicolas.filotto(a)exoplatform.com
-    * 21 janv. 2010
-    */
-   private static interface LockActionNonTxAware<R, A>
-   {
-      R execute(A arg) throws LockException;
-   }
-
 }


Property changes on:
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/infinispan/InfinispanLockManagerImpl.java
___________________________________________________________________
Name: svn:keywords
   + Id

Added:
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/jbosscache/AbstractCacheableLockManagerImpl.java
===================================================================
---
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/jbosscache/AbstractCacheableLockManagerImpl.java	
                       (rev 0)
+++
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/jbosscache/AbstractCacheableLockManagerImpl.java	2010-07-21
08:00:15 UTC (rev 2806)
@@ -0,0 +1,775 @@
+/*
+ * Copyright (C) 2003-2010 eXo Platform SAS.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program 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 this program; if not, see<http://www.gnu.org/licenses/>;.
+ */
+package org.exoplatform.services.jcr.impl.core.lock.jbosscache;
+
+import org.exoplatform.management.annotations.Managed;
+import org.exoplatform.management.annotations.ManagedDescription;
+import org.exoplatform.services.jcr.config.RepositoryConfigurationException;
+import org.exoplatform.services.jcr.config.WorkspaceEntry;
+import org.exoplatform.services.jcr.dataflow.ChangesLogIterator;
+import org.exoplatform.services.jcr.dataflow.CompositeChangesLog;
+import org.exoplatform.services.jcr.dataflow.DataManager;
+import org.exoplatform.services.jcr.dataflow.ItemState;
+import org.exoplatform.services.jcr.dataflow.ItemStateChangesLog;
+import org.exoplatform.services.jcr.dataflow.PlainChangesLog;
+import org.exoplatform.services.jcr.dataflow.PlainChangesLogImpl;
+import org.exoplatform.services.jcr.dataflow.TransactionChangesLog;
+import org.exoplatform.services.jcr.dataflow.persistent.ItemsPersistenceListener;
+import org.exoplatform.services.jcr.datamodel.ItemData;
+import org.exoplatform.services.jcr.datamodel.NodeData;
+import org.exoplatform.services.jcr.datamodel.PropertyData;
+import org.exoplatform.services.jcr.datamodel.QPathEntry;
+import org.exoplatform.services.jcr.impl.Constants;
+import org.exoplatform.services.jcr.impl.core.SessionDataManager;
+import org.exoplatform.services.jcr.impl.core.lock.LockRemover;
+import org.exoplatform.services.jcr.impl.core.lock.SessionLockManager;
+import org.exoplatform.services.jcr.impl.dataflow.TransientItemData;
+import org.exoplatform.services.jcr.impl.dataflow.TransientPropertyData;
+import
org.exoplatform.services.jcr.impl.dataflow.persistent.WorkspacePersistentDataManager;
+import org.exoplatform.services.jcr.impl.storage.JCRInvalidItemStateException;
+import org.exoplatform.services.jcr.observation.ExtendedEvent;
+import org.exoplatform.services.log.ExoLogger;
+import org.exoplatform.services.log.Log;
+import org.exoplatform.services.security.IdentityConstants;
+import org.picocontainer.Startable;
+
+import java.math.BigInteger;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import javax.jcr.RepositoryException;
+import javax.jcr.lock.LockException;
+import javax.transaction.Transaction;
+import javax.transaction.TransactionManager;
+
+/**
+ * Created by The eXo Platform SAS.
+ * 
+ * <br/>Date: 
+ *
+ * @author <a href=&quot;karpenko.sergiy(a)gmail.com&quot;&gt;Karpenko Sergiy</a>

+ * @version $Id$
+ */
+public abstract class AbstractCacheableLockManagerImpl implements CacheableLockManager,
ItemsPersistenceListener,
+   Startable
+{
+   /**
+    *  The name to property time out.  
+    */
+   public static final String TIME_OUT = "time-out";
+
+   /**
+    * Default lock time out. 30min
+    */
+   public static final long DEFAULT_LOCK_TIMEOUT = 1000 * 60 * 30;
+
+   /**
+    * Data manager.
+    */
+   protected final DataManager dataManager;
+
+   /**
+    * Run time lock time out.
+    */
+   protected long lockTimeOut;
+
+   /**
+    * Lock remover thread.
+    */
+   protected LockRemover lockRemover;
+
+   /**
+    * SessionLockManagers that uses this LockManager.
+    */
+   protected Map<String, CacheableSessionLockManager> sessionLockManagers;
+
+   /**
+    * The current Transaction Manager
+    */
+   protected TransactionManager tm;
+
+   /**
+    * Logger
+    */
+   private final Log LOG =
ExoLogger.getLogger("exo.jcr.component.core.AbstractCacheableLockManagerImpl");
+
+   protected LockActionNonTxAware<Integer, Object> getNumLocks;
+
+   protected LockActionNonTxAware<Boolean, Object> hasLocks;
+
+   protected LockActionNonTxAware<Boolean, String> isLockLive;
+
+   protected LockActionNonTxAware<Object, LockData> refresh;
+
+   protected LockActionNonTxAware<Boolean, String> lockExist;
+
+   protected LockActionNonTxAware<LockData, String> getLockDataById;
+
+   protected LockActionNonTxAware<List<LockData>, Object> getLockList;
+
+   /**
+    * Constructor.
+    * 
+    * @param dataManager - workspace persistent data manager
+    * @param config - workspace entry
+    * @param transactionManager 
+    *          the transaction manager
+    * @throws RepositoryConfigurationException 
+    */
+   public AbstractCacheableLockManagerImpl(WorkspacePersistentDataManager dataManager,
WorkspaceEntry config,
+      TransactionManager transactionManager) throws RepositoryConfigurationException
+   {
+      if (config.getLockManager() != null)
+      {
+         if (config.getLockManager().getParameters() != null
+            && config.getLockManager().getParameterValue(TIME_OUT, null) !=
null)
+         {
+            long timeOut = config.getLockManager().getParameterTime(TIME_OUT);
+            lockTimeOut = timeOut > 0 ? timeOut : DEFAULT_LOCK_TIMEOUT;
+         }
+         else
+         {
+            lockTimeOut =
+               config.getLockManager().getTimeout() > 0 ?
config.getLockManager().getTimeout() : DEFAULT_LOCK_TIMEOUT;
+         }
+      }
+      else
+      {
+         lockTimeOut = DEFAULT_LOCK_TIMEOUT;
+      }
+
+      this.dataManager = dataManager;
+      this.sessionLockManagers = new ConcurrentHashMap<String,
CacheableSessionLockManager>();
+      this.tm = transactionManager;
+
+      dataManager.addItemPersistenceListener(this);
+   }
+
+   @Managed
+   @ManagedDescription("Remove the expired locks")
+   public void cleanExpiredLocks()
+   {
+      removeExpired();
+   }
+
+   public long getDefaultLockTimeOut()
+   {
+      return lockTimeOut;
+   }
+
+   @Managed
+   @ManagedDescription("The number of active locks")
+   public int getNumLocks()
+   {
+      try
+      {
+         return executeLockActionNonTxAware(getNumLocks, null);
+      }
+      catch (LockException e)
+      {
+         // ignore me will never occur
+      }
+      return -1;
+   }
+
+   /**
+    * Indicates if some locks have already been created
+    */
+   protected boolean hasLocks()
+   {
+      try
+      {
+         return executeLockActionNonTxAware(hasLocks, null);
+      }
+      catch (LockException e)
+      {
+         // ignore me will never occur
+      }
+      return true;
+   }
+
+   /**
+    * Return new instance of session lock manager.
+    */
+   public SessionLockManager getSessionLockManager(String sessionId, SessionDataManager
transientManager)
+   {
+      CacheableSessionLockManager sessionManager = new
CacheableSessionLockManager(sessionId, this, transientManager);
+      sessionLockManagers.put(sessionId, sessionManager);
+      return sessionManager;
+   }
+
+   /**
+    * Check is LockManager contains lock. No matter it is in pending or persistent
state.
+    * 
+    * @param nodeId - locked node id
+    * @return 
+    */
+   public boolean isLockLive(String nodeId) throws LockException
+   {
+      try
+      {
+         return executeLockActionNonTxAware(isLockLive, nodeId);
+      }
+      catch (LockException e)
+      {
+         // ignore me will never occur
+      }
+      return false;
+   }
+
+   /**
+    * {@inheritDoc}
+    */
+   public boolean isTXAware()
+   {
+      return true;
+   }
+
+   /**
+    * {@inheritDoc}
+    */
+   public void onSaveItems(ItemStateChangesLog changesLog)
+   {
+      List<PlainChangesLog> chengesLogList = new
ArrayList<PlainChangesLog>();
+      if (changesLog instanceof TransactionChangesLog)
+      {
+         ChangesLogIterator logIterator =
((TransactionChangesLog)changesLog).getLogIterator();
+
+         while (logIterator.hasNextLog())
+         {
+            chengesLogList.add(logIterator.nextLog());
+         }
+      }
+      else if (changesLog instanceof PlainChangesLog)
+      {
+         chengesLogList.add((PlainChangesLog)changesLog);
+      }
+      else if (changesLog instanceof CompositeChangesLog)
+      {
+         for (ChangesLogIterator iter =
((CompositeChangesLog)changesLog).getLogIterator(); iter.hasNextLog();)
+         {
+            chengesLogList.add(iter.nextLog());
+         }
+      }
+
+      List<LockOperationContainer> containers = new
ArrayList<LockOperationContainer>();
+
+      for (PlainChangesLog currChangesLog : chengesLogList)
+      {
+         String sessionId = currChangesLog.getSessionId();
+
+         String nodeIdentifier;
+         try
+         {
+            switch (currChangesLog.getEventType())
+            {
+               case ExtendedEvent.LOCK :
+                  if (currChangesLog.getSize() < 2)
+                  {
+                     LOG.error("Incorrect changes log  of type ExtendedEvent.LOCK
size=" + currChangesLog.getSize()
+                        + "<2 \n" + currChangesLog.dump());
+                     break;
+                  }
+                  nodeIdentifier =
currChangesLog.getAllStates().get(0).getData().getParentIdentifier();
+
+                  CacheableSessionLockManager session =
sessionLockManagers.get(sessionId);
+                  if (session != null &&
session.containsPendingLock(nodeIdentifier))
+                  {
+                     containers.add(new LockOperationContainer(nodeIdentifier,
currChangesLog.getSessionId(),
+                        ExtendedEvent.LOCK));
+                  }
+                  else
+                  {
+                     LOG.error("Lock must exist in pending locks.");
+                  }
+                  break;
+               case ExtendedEvent.UNLOCK :
+                  if (currChangesLog.getSize() < 2)
+                  {
+                     LOG.error("Incorrect changes log  of type ExtendedEvent.UNLOCK
size=" + currChangesLog.getSize()
+                        + "<2 \n" + currChangesLog.dump());
+                     break;
+                  }
+
+                  containers.add(new
LockOperationContainer(currChangesLog.getAllStates().get(0).getData()
+                     .getParentIdentifier(), currChangesLog.getSessionId(),
ExtendedEvent.UNLOCK));
+                  break;
+               default :
+                  HashSet<String> removedLock = new HashSet<String>();
+                  for (ItemState itemState : currChangesLog.getAllStates())
+                  {
+                     // this is a node and node is locked
+                     if (itemState.getData().isNode() &&
lockExist(itemState.getData().getIdentifier()))
+                     {
+                        nodeIdentifier = itemState.getData().getIdentifier();
+                        if (itemState.isDeleted())
+                        {
+                           removedLock.add(nodeIdentifier);
+                        }
+                        else if (itemState.isAdded() || itemState.isRenamed() ||
itemState.isUpdated())
+                        {
+                           removedLock.remove(nodeIdentifier);
+                        }
+                     }
+                  }
+                  for (String identifier : removedLock)
+                  {
+                     containers.add(new LockOperationContainer(identifier,
currChangesLog.getSessionId(),
+                        ExtendedEvent.UNLOCK));
+                  }
+                  break;
+            }
+         }
+         catch (IllegalStateException e)
+         {
+            LOG.error(e.getLocalizedMessage(), e);
+         }
+      }
+
+      // sort locking and unlocking operations to avoid deadlocks
+      Collections.sort(containers);
+      for (LockOperationContainer container : containers)
+      {
+         try
+         {
+            container.apply();
+         }
+         catch (LockException e)
+         {
+            LOG.error(e.getMessage(), e);
+         }
+      }
+   }
+
+   /**
+    * Class containing operation type (LOCK or UNLOCK) and all the needed information
like node uuid and session id.
+    */
+   private class LockOperationContainer implements
Comparable<LockOperationContainer>
+   {
+
+      private String identifier;
+
+      private String sessionId;
+
+      private int type;
+
+      /**
+       * @param identifier node identifier 
+       * @param sessionId id of session
+       * @param type ExtendedEvent type specifying the operation (LOCK or UNLOCK)
+       */
+      public LockOperationContainer(String identifier, String sessionId, int type)
+      {
+         super();
+         this.identifier = identifier;
+         this.sessionId = sessionId;
+         this.type = type;
+      }
+
+      /**
+       * @return node identifier
+       */
+      public String getIdentifier()
+      {
+         return identifier;
+      }
+
+      public void apply() throws LockException
+      {
+         // invoke internalLock in LOCK operation
+         if (type == ExtendedEvent.LOCK)
+         {
+            internalLock(sessionId, identifier);
+         }
+         // invoke internalUnLock in UNLOCK operation
+         else if (type == ExtendedEvent.UNLOCK)
+         {
+            internalUnLock(sessionId, identifier);
+         }
+      }
+
+      /**
+       * @see java.lang.Comparable#compareTo(java.lang.Object)
+       */
+      public int compareTo(LockOperationContainer o)
+      {
+         return identifier.compareTo(o.getIdentifier());
+      }
+   }
+
+   /**
+    * Refreshed lock data in cache
+    * 
+    * @param newLockData
+    */
+   public void refreshLockData(LockData newLockData) throws LockException
+   {
+      executeLockActionNonTxAware(refresh, newLockData);
+   }
+
+   /**
+    * Remove expired locks. Used from LockRemover.
+    */
+   public synchronized void removeExpired()
+   {
+      final List<String> removeLockList = new ArrayList<String>();
+
+      for (LockData lock : getLockList())
+      {
+         if (!lock.isSessionScoped() && lock.getTimeToDeath() < 0)
+         {
+            removeLockList.add(lock.getNodeIdentifier());
+         }
+      }
+
+      Collections.sort(removeLockList);
+
+      for (String rLock : removeLockList)
+      {
+         removeLock(rLock);
+      }
+   }
+
+   /**
+    * {@inheritDoc}
+    */
+   public void start()
+   {
+      lockRemover = new LockRemover(this);
+   }
+
+   /**
+    * {@inheritDoc}
+    */
+   public void stop()
+   {
+      lockRemover.halt();
+      lockRemover.interrupt();
+      sessionLockManagers.clear();
+   }
+
+   /**
+    * Copy <code>PropertyData prop<code> to new TransientItemData
+    * 
+    * @param prop
+    * @return
+    * @throws RepositoryException
+    */
+   protected TransientItemData copyItemData(PropertyData prop) throws
RepositoryException
+   {
+      if (prop == null)
+      {
+         return null;
+      }
+
+      // make a copy, value may be null for deleting items
+      TransientPropertyData newData =
+         new TransientPropertyData(prop.getQPath(), prop.getIdentifier(),
prop.getPersistedVersion(), prop.getType(),
+            prop.getParentIdentifier(), prop.isMultiValued(), prop.getValues());
+
+      return newData;
+   }
+
+   /**
+    * Internal lock
+    * 
+    * @param nodeIdentifier
+    * @throws LockException
+    */
+   protected abstract void internalLock(String sessionId, String nodeIdentifier) throws
LockException;
+
+   /**
+    * Internal unlock.
+    * 
+    * @param sessionId
+    * @param nodeIdentifier
+    * @throws LockException
+    */
+   protected abstract void internalUnLock(String sessionId, String nodeIdentifier) throws
LockException;
+
+   /**
+    * {@inheritDoc}
+    */
+   public boolean lockExist(String nodeId)
+   {
+      try
+      {
+         return executeLockActionNonTxAware(lockExist, nodeId);
+      }
+      catch (LockException e)
+      {
+         // ignore me will never occur
+      }
+      return false;
+   }
+
+   /**
+    * {@inheritDoc}
+    */
+   public String getLockTokenHash(String token)
+   {
+      String hash = "";
+      try
+      {
+         MessageDigest m = MessageDigest.getInstance("MD5");
+         m.update(token.getBytes(), 0, token.length());
+         hash = new BigInteger(1, m.digest()).toString(16);
+      }
+      catch (NoSuchAlgorithmException e)
+      {
+         LOG.error("Can't get instanse of MD5 MessageDigest!", e);
+      }
+      return hash;
+   }
+
+   /**
+    * {@inheritDoc}
+    */
+   public LockData getExactNodeOrCloseParentLock(NodeData node) throws
RepositoryException
+   {
+      return getExactNodeOrCloseParentLock(node, true);
+   }
+
+   private LockData getExactNodeOrCloseParentLock(NodeData node, boolean checkHasLocks)
throws RepositoryException
+   {
+
+      if (node == null || (checkHasLocks && !hasLocks()))
+      {
+         return null;
+      }
+      LockData retval = null;
+      retval = getLockDataById(node.getIdentifier());
+      if (retval == null)
+      {
+         NodeData parentData =
(NodeData)dataManager.getItemData(node.getParentIdentifier());
+         if (parentData != null)
+         {
+            retval = getExactNodeOrCloseParentLock(parentData, false);
+         }
+      }
+      return retval;
+   }
+
+   /**
+    * {@inheritDoc}
+    */
+   public LockData getExactNodeLock(NodeData node) throws RepositoryException
+   {
+      if (node == null || !hasLocks())
+      {
+         return null;
+      }
+
+      return getLockDataById(node.getIdentifier());
+   }
+
+   /**
+    * {@inheritDoc}
+    */
+   public LockData getClosedChild(NodeData node) throws RepositoryException
+   {
+      return getClosedChild(node, true);
+   }
+
+   private LockData getClosedChild(NodeData node, boolean checkHasLocks) throws
RepositoryException
+   {
+
+      if (node == null || (checkHasLocks && !hasLocks()))
+      {
+         return null;
+      }
+      LockData retval = null;
+
+      List<NodeData> childData = dataManager.getChildNodesData(node);
+      for (NodeData nodeData : childData)
+      {
+         retval = getLockDataById(nodeData.getIdentifier());
+         if (retval != null)
+            return retval;
+      }
+      // child not found try to find dipper
+      for (NodeData nodeData : childData)
+      {
+         retval = getClosedChild(nodeData, false);
+         if (retval != null)
+            return retval;
+      }
+      return retval;
+   }
+
+   protected LockData getLockDataById(String nodeId)
+   {
+      try
+      {
+         return executeLockActionNonTxAware(getLockDataById, nodeId);
+      }
+      catch (LockException e)
+      {
+         // ignore me will never occur
+      }
+      return null;
+   }
+
+   protected synchronized List<LockData> getLockList()
+   {
+      try
+      {
+         return executeLockActionNonTxAware(getLockList, null);
+      }
+      catch (LockException e)
+      {
+         // ignore me will never occur
+      }
+      return null;
+   }
+
+   /**
+    * Remove lock, used by Lock remover.
+    * 
+    * @param nodeIdentifier String
+    */
+   protected void removeLock(String nodeIdentifier)
+   {
+      try
+      {
+         NodeData nData = (NodeData)dataManager.getItemData(nodeIdentifier);
+
+         //TODO EXOJCR-412, should be refactored in future.
+         //Skip removing, because that node was removed in other node of cluster.  
+         if (nData == null)
+         {
+            return;
+         }
+
+         PlainChangesLog changesLog =
+            new PlainChangesLogImpl(new ArrayList<ItemState>(),
IdentityConstants.SYSTEM, ExtendedEvent.UNLOCK);
+
+         ItemData lockOwner =
+            copyItemData((PropertyData)dataManager.getItemData(nData, new
QPathEntry(Constants.JCR_LOCKOWNER, 1)));
+
+         //TODO EXOJCR-412, should be refactored in future.
+         //Skip removing, because that lock was removed in other node of cluster.  
+         if (lockOwner == null)
+         {
+            return;
+         }
+
+         changesLog.add(ItemState.createDeletedState(lockOwner));
+
+         ItemData lockIsDeep =
+            copyItemData((PropertyData)dataManager.getItemData(nData, new
QPathEntry(Constants.JCR_LOCKISDEEP, 1)));
+
+         //TODO EXOJCR-412, should be refactored in future.
+         //Skip removing, because that lock was removed in other node of cluster.  
+         if (lockIsDeep == null)
+         {
+            return;
+         }
+
+         changesLog.add(ItemState.createDeletedState(lockIsDeep));
+
+         // lock probably removed by other thread
+         if (lockOwner == null && lockIsDeep == null)
+         {
+            return;
+         }
+
+         dataManager.save(new TransactionChangesLog(changesLog));
+      }
+      catch (JCRInvalidItemStateException e)
+      {
+         //TODO EXOJCR-412, should be refactored in future.
+         //Skip property not found in DB, because that lock property was removed in other
node of cluster.
+         if (LOG.isDebugEnabled())
+         {
+            LOG.debug("The propperty was removed in other node of cluster.",
e);
+         }
+
+      }
+      catch (RepositoryException e)
+      {
+         LOG.error("Error occur during removing lock" +
e.getLocalizedMessage(), e);
+      }
+   }
+
+   /**
+    * {@inheritDoc}
+    */
+   public void closeSessionLockManager(String sessionID)
+   {
+      sessionLockManagers.remove(sessionID);
+   }
+
+   /**
+    * Execute the given action outside a transaction. This is needed since the {@link
Cache} used by {@link CacheableLockManagerImpl}
+    * manages the persistence of its locks thanks to a {@link CacheLoader} and a {@link
CacheLoader} lock the JBoss cache {@link Node}
+    * even for read operations which cause deadlock issue when a XA {@link Transaction}
is already opened
+    * @throws LockException when a exception occurs
+    */
+   private <R, A> R executeLockActionNonTxAware(LockActionNonTxAware<R, A>
action, A arg) throws LockException
+   {
+      Transaction tx = null;
+      try
+      {
+         if (tm != null)
+         {
+            try
+            {
+               tx = tm.suspend();
+            }
+            catch (Exception e)
+            {
+               LOG.warn("Cannot suspend the current transaction", e);
+            }
+         }
+         return action.execute(arg);
+      }
+      finally
+      {
+         if (tx != null)
+         {
+            try
+            {
+               tm.resume(tx);
+            }
+            catch (Exception e)
+            {
+               LOG.warn("Cannot resume the current transaction", e);
+            }
+         }
+      }
+   }
+
+   /**
+    * Actions that are not supposed to be called within a transaction
+    * 
+    * Created by The eXo Platform SAS
+    * Author : Nicolas Filotto 
+    *          nicolas.filotto(a)exoplatform.com
+    * 21 janv. 2010
+    */
+   protected static interface LockActionNonTxAware<R, A>
+   {
+      R execute(A arg) throws LockException;
+   }
+}


Property changes on:
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/jbosscache/AbstractCacheableLockManagerImpl.java
___________________________________________________________________
Name: svn:keywords
   + Id

Modified:
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/infinispan/InfinispanCacheFactory.java
===================================================================
---
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/infinispan/InfinispanCacheFactory.java	2010-07-20
15:58:02 UTC (rev 2805)
+++
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/infinispan/InfinispanCacheFactory.java	2010-07-21
08:00:15 UTC (rev 2806)
@@ -44,7 +44,7 @@
  * in Infinispan (this is highly recommended by RH specialists).
  * 
  * @author <a href="mailto:nikolazius@gmail.com">Nikolay
Zamosenchuk</a>
- * @version $Id: ExoCacheFactoryImpl.java 34360 2009-07-22 23:58:59Z nzamosenchuk $
+ * @version $Id$
  *
  */
 public class InfinispanCacheFactory<K, V>


Property changes on:
jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/infinispan/InfinispanCacheFactory.java
___________________________________________________________________
Name: svn:keywords
   + Id


    

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

[exo-jcr-commits] exo-jcr SVN: r2806 - in jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr: impl/core/lock/jbosscache and 1 other directories.