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

Author: tolusha Date: 2010-07-30 09:00:43 -0400 (Fri, 30 Jul 2010) New Revision: 2843 Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/BufferedISPNCache.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheId.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheKey.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheNodesId.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CachePropsId.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheQPath.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CompressedISPNChangesBuffer.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/ISPNCacheWorkspaceStorageCache.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan-config.xml jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan-lock.xml Removed: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan.xml Modified: jcr/branches/1.14-ISPN/exo.jcr.component.core/pom.xml jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/infinispan/ISPNCacheableLockManagerImpl.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/util/io/PrivilegedCacheHelper.java 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/test/java/org/exoplatform/services/jcr/api/writing/TestOrderBefore.java jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-jcr-config.xml Log: EXOJCR-830: first step to impl. problems with SNS Modified: jcr/branches/1.14-ISPN/exo.jcr.component.core/pom.xml =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/pom.xml 2010-07-30 11:40:38 UTC (rev 2842) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/pom.xml 2010-07-30 13:00:43 UTC (rev 2843) @@ -404,10 +404,11 @@ </property--> </systemProperties> <includes> - <include>org/exoplatform/services/jcr/api/**/Test*.java</include> + <!--include>org/exoplatform/services/jcr/api/**/Test*.java</include> <include>org/exoplatform/services/jcr/usecases/**/Test*.java</include> <include>org/exoplatform/services/jcr/usecases/**/*Test.java</include> - <include>org/exoplatform/services/jcr/impl/**/Test*.java</include> + <include>org/exoplatform/services/jcr/impl/**/Test*.java</include--> +<include>**/**/TestOrderBefore.java</include> </includes> <excludes> <exclude>org/exoplatform/services/jcr/**/TestQueryUsecases.java</exclude> Modified: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/infinispan/ISPNCacheableLockManagerImpl.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/infinispan/ISPNCacheableLockManagerImpl.java 2010-07-30 11:40:38 UTC (rev 2842) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/lock/infinispan/ISPNCacheableLockManagerImpl.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -156,7 +156,7 @@ { public Object execute(LockData newLockData) throws LockException { - Object oldValue = PrivilegedCacheHelper.putIfAbsent(cache, newLockData.getNodeIdentifier(), newLockData); + Object oldValue = PrivilegedCacheHelper.put(cache, newLockData.getNodeIdentifier(), newLockData); if (oldValue == null) { throw new LockException("Can't refresh lock for node " + newLockData.getNodeIdentifier() @@ -369,7 +369,7 @@ LockData lockData = session.getPendingLock(nodeIdentifier); // this will return null if success. And old data if something exists... - LockData oldLockData = (LockData)PrivilegedCacheHelper.putIfAbsent(cache, nodeIdentifier, lockData); + LockData oldLockData = (LockData)PrivilegedCacheHelper.put(cache, nodeIdentifier, lockData); if (oldLockData != null) { Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/BufferedISPNCache.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/BufferedISPNCache.java (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/BufferedISPNCache.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,1073 @@ +/* + * Copyright (C) 2009 eXo Platform SAS. + * + * This 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 software 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 this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan; + +import org.exoplatform.services.log.ExoLogger; +import org.exoplatform.services.log.Log; +import org.infinispan.AdvancedCache; +import org.infinispan.Cache; +import org.infinispan.config.Configuration; +import org.infinispan.context.Flag; +import org.infinispan.lifecycle.ComponentStatus; +import org.infinispan.manager.CacheContainer; +import org.infinispan.util.concurrent.NotifyingFuture; + +import java.io.Serializable; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.TimeUnit; + +/** + * Decorator over the JBossCache that stores changes in buffer, then sorts and applies to + * JBossCache. + * + * @author <a href="mailto:Sergey.Kabashnyuk@exoplatform.org">Sergey Kabashnyuk</a> + * @version $Id: BufferedJBossCache.java 34360 2009-07-22 23:58:59Z nzamosenchuk $ + * + */ +@SuppressWarnings("unchecked") +public class BufferedISPNCache implements Cache<Serializable, Object> +{ + /** + * Parent cache. + */ + private final Cache<Serializable, Object> parentCache; + + private final ThreadLocal<CompressedISPNChangesBuffer> changesList = new ThreadLocal<CompressedISPNChangesBuffer>(); + + private ThreadLocal<Boolean> local = new ThreadLocal<Boolean>(); + + private final boolean useExpiration; + + private final long expirationTimeOut; + + protected static final Log LOG = ExoLogger.getLogger("exo.jcr.component.core.BufferedISPNCache"); + + public static enum ChangesType { + REMOVE, PUT; + } + + /** + * Container for changes + */ + public static abstract class ChangesContainer implements Comparable<ChangesContainer> + { + protected final CacheKey key; + + protected final ChangesType changesType; + + protected final Cache<Serializable, Object> cache; + + protected final int historicalIndex; + + protected final boolean localMode; + + protected final boolean useExpiration; + + protected final long timeOut; + + public ChangesContainer(CacheKey key, ChangesType changesType, Cache<Serializable, Object> cache, + int historicalIndex, boolean localMode, boolean useExpiration, long timeOut) + { + super(); + this.key = key; + this.changesType = changesType; + this.cache = cache; + this.historicalIndex = historicalIndex; + this.localMode = localMode; + this.useExpiration = useExpiration; + this.timeOut = timeOut; + } + + /** + * @return the key + */ + public CacheKey getKey() + { + return key; + } + + /** + * @return the index of change in original sequence + */ + public int getHistoricalIndex() + { + return historicalIndex; + } + + /** + * @return the changesType + */ + public ChangesType getChangesType() + { + return changesType; + } + + /** + * {@inheritDoc} + */ + @Override + public String toString() + { + return key.toString() + " type=" + changesType + " historyIndex=" + historicalIndex; + } + + /** + * {@inheritDoc} + */ + public int compareTo(ChangesContainer o) + { + int result = key.compareTo(o.getKey()); + return result == 0 ? historicalIndex - o.getHistoricalIndex() : result; + } + + protected void setCacheLocalMode() + { + if (localMode) + { + cache.getAdvancedCache().getInvocationContextContainer().getInvocationContext().setFlags( + Flag.CACHE_MODE_LOCAL); + } + else + { + Set<Flag> flags = + cache.getAdvancedCache().getInvocationContextContainer().getInvocationContext().getFlags(); + + if (flags != null) + { + flags.remove(Flag.CACHE_MODE_LOCAL); + cache.getAdvancedCache().getInvocationContextContainer().getInvocationContext().setFlags(flags); + } + } + } + + public final void putExpiration(CacheKey key) + { + // setCacheLocalMode(); + // // TODO + // cache.put(efqn, ExpirationAlgorithmConfig.EXPIRATION_KEY, new Long(System.currentTimeMillis() + timeOut)); + } + + public abstract void apply(); + } + + /** + * Put object container; + */ + public static class PutObjectContainer extends ChangesContainer + { + private final Object value; + + public PutObjectContainer(CacheKey key, Object value, Cache<Serializable, Object> cache, int historicalIndex, + boolean local, boolean useExpiration, long timeOut) + { + super(key, ChangesType.PUT, cache, historicalIndex, local, useExpiration, timeOut); + + this.value = value; + } + + @Override + public void apply() + { + setCacheLocalMode(); + cache.put(key, value); + + if (useExpiration) + { + putExpiration(key); + } + } + } + + /** + * It tries to get Set by given key. If it is Set then adds new value and puts new set back. If + * null found, then new Set created (ordinary cache does). + */ + public static class AddToListContainer extends ChangesContainer + { + private final Object value; + + public AddToListContainer(CacheKey key, Object value, Cache<Serializable, Object> cache, int historicalIndex, + boolean local, boolean useExpiration, long timeOut) + { + super(key, ChangesType.PUT, cache, historicalIndex, local, useExpiration, timeOut); + this.value = value; + } + + @Override + public void apply() + { + // force writeLock on next read + cache.getAdvancedCache().getInvocationContextContainer().getInvocationContext() + .setFlags(Flag.FORCE_WRITE_LOCK); + + Object existingObject = cache.get(key); + Set<Object> newSet = new HashSet<Object>(); + + // if set found of null, perform add + if (existingObject instanceof Set || existingObject == null) + { + // set found + if (existingObject instanceof Set) + { + newSet.addAll((Set<Object>)existingObject); + } + newSet.add(value); + + if (useExpiration) + { + putExpiration(key); + } + + setCacheLocalMode(); + cache.put(key, newSet); + } + else + { + LOG.error("Unexpected object found by key " + key.toString() + ". Expected Set, but found:" + + existingObject.getClass().getName()); + } + } + } + + /** + * It tries to get set by given key. If it is set then removes value and puts new modified set + * back. + */ + public static class RemoveFromListContainer extends ChangesContainer + { + private final Object value; + + public RemoveFromListContainer(CacheKey key, Object value, Cache<Serializable, Object> cache, + int historicalIndex, boolean local, boolean useExpiration, long timeOut) + { + super(key, ChangesType.REMOVE, cache, historicalIndex, local, useExpiration, timeOut); + this.value = value; + } + + @Override + public void apply() + { + // force writeLock on next read + cache.getAdvancedCache().getInvocationContextContainer().getInvocationContext() + .setFlags(Flag.FORCE_WRITE_LOCK); + + setCacheLocalMode(); + + Object existingObject = cache.get(key); + + // if found value is really set! add to it. + if (existingObject instanceof Set) + { + Set<Object> newSet = new HashSet<Object>((Set<Object>)existingObject); + newSet.remove(value); + + if (useExpiration) + { + putExpiration(key); + } + + setCacheLocalMode(); + cache.put(key, newSet); + } + } + } + + /** + * Remove container. + */ + public static class RemoveObjectContainer extends ChangesContainer + { + public RemoveObjectContainer(CacheKey key, Cache<Serializable, Object> cache, int historicalIndex, boolean local, + boolean useExpiration, long timeOut) + { + super(key, ChangesType.REMOVE, cache, historicalIndex, local, useExpiration, timeOut); + } + + @Override + public void apply() + { + setCacheLocalMode(); + cache.remove(key); + } + } + + public BufferedISPNCache(Cache<Serializable, Object> parentCache, boolean useExpiration, long expirationTimeOut) + { + super(); + this.parentCache = parentCache; + this.useExpiration = useExpiration; + this.expirationTimeOut = expirationTimeOut; + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Void> clearAsync() + { + return parentCache.clearAsync(); + } + + /** + * {@inheritDoc} + */ + @Override + public void compact() + { + parentCache.compact(); + } + + /** + * {@inheritDoc} + */ + @Override + public void endBatch(boolean successful) + { + parentCache.endBatch(successful); + } + + /** + * {@inheritDoc} + */ + @Override + public Set<java.util.Map.Entry<Serializable, Object>> entrySet() + { + return parentCache.entrySet(); + } + + /** + * {@inheritDoc} + */ + @Override + public void evict(Serializable key) + { + parentCache.evict(key); + } + + /** + * {@inheritDoc} + */ + @Override + public AdvancedCache<Serializable, Object> getAdvancedCache() + { + return parentCache.getAdvancedCache(); + } + + /** + * {@inheritDoc} + */ + @Override + public CacheContainer getCacheManager() + { + return parentCache.getCacheManager(); + } + + /** + * {@inheritDoc} + */ + @Override + public Configuration getConfiguration() + { + return parentCache.getConfiguration(); + } + + /** + * {@inheritDoc} + */ + @Override + public String getName() + { + return parentCache.getName(); + } + + /** + * {@inheritDoc} + */ + @Override + public ComponentStatus getStatus() + { + return parentCache.getStatus(); + } + + /** + * {@inheritDoc} + */ + @Override + public String getVersion() + { + return parentCache.getVersion(); + } + + /** + * {@inheritDoc} + */ + @Override + public Set<Serializable> keySet() + { + return parentCache.keySet(); + } + + /** + * {@inheritDoc} + */ + @Override + public Object put(Serializable key, Object value, long lifespan, TimeUnit unit) + { + return parentCache.put(key, value, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public Object put(Serializable key, Object value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, + TimeUnit maxIdleTimeUnit) + { + return parentCache.put(key, value, lifespan, lifespanUnit, maxIdleTime, maxIdleTimeUnit); + } + + /** + * {@inheritDoc} + */ + @Override + public void putAll(Map<? extends Serializable, ? extends Object> map, long lifespan, TimeUnit unit) + { + parentCache.putAll(map, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public void putAll(Map<? extends Serializable, ? extends Object> map, long lifespan, TimeUnit lifespanUnit, + long maxIdleTime, TimeUnit maxIdleTimeUnit) + { + parentCache.putAll(map, lifespan, lifespanUnit, maxIdleTime, maxIdleTimeUnit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Void> putAllAsync(Map<? extends Serializable, ? extends Object> data) + { + return parentCache.putAllAsync(data); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Void> putAllAsync(Map<? extends Serializable, ? extends Object> data, long lifespan, + TimeUnit unit) + { + return parentCache.putAllAsync(data, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Void> putAllAsync(Map<? extends Serializable, ? extends Object> data, long lifespan, + TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit) + { + return parentCache.putAllAsync(data, lifespan, lifespanUnit, maxIdle, maxIdleUnit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> putAsync(Serializable key, Object value) + { + return parentCache.putAsync(key, value); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> putAsync(Serializable key, Object value, long lifespan, TimeUnit unit) + { + return parentCache.putAsync(key, value, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> putAsync(Serializable key, Object value, long lifespan, TimeUnit lifespanUnit, + long maxIdle, TimeUnit maxIdleUnit) + { + return parentCache.putAsync(key, value, lifespan, lifespanUnit, maxIdle, maxIdleUnit); + } + + /** + * {@inheritDoc} + */ + @Override + public void putForExternalRead(Serializable key, Object value) + { + parentCache.putForExternalRead(key, value); + } + + /** + * {@inheritDoc} + */ + @Override + public Object putIfAbsent(Serializable key, Object value, long lifespan, TimeUnit unit) + { + return parentCache.putIfAbsent(key, value, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public Object putIfAbsent(Serializable key, Object value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, + TimeUnit maxIdleTimeUnit) + { + return parentCache.putIfAbsent(key, value, lifespan, lifespanUnit, maxIdleTime, maxIdleTimeUnit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> putIfAbsentAsync(Serializable key, Object value) + { + return parentCache.putIfAbsentAsync(key, value); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> putIfAbsentAsync(Serializable key, Object value, long lifespan, TimeUnit unit) + { + return parentCache.putIfAbsentAsync(key, value, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> putIfAbsentAsync(Serializable key, Object value, long lifespan, + TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit) + { + return parentCache.putIfAbsentAsync(key, value, lifespan, lifespanUnit, maxIdle, maxIdleUnit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> removeAsync(Object key) + { + return parentCache.removeAsync(key); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Boolean> removeAsync(Object key, Object value) + { + return parentCache.removeAsync(key, value); + } + + /** + * {@inheritDoc} + */ + @Override + public Object replace(Serializable key, Object value, long lifespan, TimeUnit unit) + { + return parentCache.replace(key, value, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean replace(Serializable key, Object oldValue, Object value, long lifespan, TimeUnit unit) + { + return parentCache.replace(key, oldValue, value, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public Object replace(Serializable key, Object value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, + TimeUnit maxIdleTimeUnit) + { + return parentCache.replace(key, value, lifespan, lifespanUnit, maxIdleTime, maxIdleTimeUnit); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean replace(Serializable key, Object oldValue, Object value, long lifespan, TimeUnit lifespanUnit, + long maxIdleTime, TimeUnit maxIdleTimeUnit) + { + return parentCache.replace(key, oldValue, value, lifespan, lifespanUnit, maxIdleTime, maxIdleTimeUnit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> replaceAsync(Serializable key, Object value) + { + return parentCache.replaceAsync(key, value); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Boolean> replaceAsync(Serializable key, Object oldValue, Object newValue) + { + return parentCache.replaceAsync(key, oldValue, newValue); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> replaceAsync(Serializable key, Object value, long lifespan, TimeUnit unit) + { + return parentCache.replaceAsync(key, value, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Boolean> replaceAsync(Serializable key, Object oldValue, Object newValue, long lifespan, + TimeUnit unit) + { + return parentCache.replaceAsync(key, oldValue, newValue, lifespan, unit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Object> replaceAsync(Serializable key, Object value, long lifespan, TimeUnit lifespanUnit, + long maxIdle, TimeUnit maxIdleUnit) + { + return parentCache.replaceAsync(key, value, lifespan, lifespanUnit, maxIdle, maxIdleUnit); + } + + /** + * {@inheritDoc} + */ + @Override + public NotifyingFuture<Boolean> replaceAsync(Serializable key, Object oldValue, Object newValue, long lifespan, + TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit) + { + return parentCache.replaceAsync(key, oldValue, newValue); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean startBatch() + { + return parentCache.startBatch(); + } + + /** + * {@inheritDoc} + */ + @Override + public Collection<Object> values() + { + return parentCache.values(); + } + + /** + * {@inheritDoc} + */ + @Override + public Object putIfAbsent(Serializable key, Object value) + { + return parentCache.putIfAbsent(key, value); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean remove(Object key, Object value) + { + return parentCache.remove(key, value); + } + + /** + * {@inheritDoc} + */ + @Override + public Object replace(Serializable key, Object value) + { + return parentCache.replace(key, value); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean replace(Serializable key, Object oldValue, Object newValue) + { + return parentCache.replace(key, oldValue, newValue); + } + + /** + * {@inheritDoc} + */ + @Override + public void clear() + { + parentCache.clear(); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean containsKey(Object key) + { + return parentCache.containsKey(key); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean containsValue(Object value) + { + return parentCache.containsValue(value); + } + + /** + * {@inheritDoc} + */ + @Override + public Object get(Object key) + { + return parentCache.get(key); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean isEmpty() + { + return parentCache.isEmpty(); + } + + /** + * + * @param key + * @param value + * @return + */ + public Object put(CacheKey key, Object value) + { + CompressedISPNChangesBuffer changesContainer = getChangesBufferSafe(); + changesContainer.add(new PutObjectContainer(key, value, parentCache, changesContainer.getHistoryIndex(), local + .get(), useExpiration, expirationTimeOut)); + + return parentCache.get(key); + } + + /** + * {@inheritDoc} + */ + @Override + public Object put(Serializable key, Object value) + { + return parentCache.put(key, value); + } + + /** + * {@inheritDoc} + */ + @Override + public void putAll(Map<? extends Serializable, ? extends Object> m) + { + parentCache.putAll(m); + } + + /** + * {@inheritDoc} + */ + @Override + public Object remove(Object key) + { + CompressedISPNChangesBuffer changesContainer = getChangesBufferSafe(); + changesContainer.add(new RemoveObjectContainer((CacheKey)key, parentCache, changesContainer.getHistoryIndex(), + local.get(), useExpiration, expirationTimeOut)); + return parentCache.get(key); + } + + /** + * {@inheritDoc} + */ + @Override + public int size() + { + return parentCache.size(); + } + + /** + * {@inheritDoc} + */ + @Override + public void start() + { + PrivilegedAction<Object> action = new PrivilegedAction<Object>() + { + public Object run() + { + parentCache.start(); + return null; + } + }; + AccessController.doPrivileged(action); + } + + /** + * {@inheritDoc} + */ + @Override + public void stop() + { + PrivilegedAction<Object> action = new PrivilegedAction<Object>() + { + public Object run() + { + parentCache.stop(); + return null; + } + }; + AccessController.doPrivileged(action); + } + + /** + * {@inheritDoc} + */ + @Override + public void addListener(Object listener) + { + parentCache.addListener(listener); + } + + /** + * {@inheritDoc} + */ + @Override + public Set<Object> getListeners() + { + return parentCache.getListeners(); + } + + /** + * {@inheritDoc} + */ + @Override + public void removeListener(Object listener) + { + parentCache.removeListener(listener); + } + + /** + * Start buffering process. + */ + public void beginTransaction() + { + changesList.set(new CompressedISPNChangesBuffer()); + local.set(false); + } + + /** + * + * @return status of the cache transaction + */ + public boolean isTransactionActive() + { + return changesList.get() != null; + } + + /** + * Sort changes and commit data to the cache. + */ + public void commitTransaction() + { + CompressedISPNChangesBuffer changesContainer = getChangesBufferSafe(); + try + { + List<ChangesContainer> containers = changesContainer.getSortedList(); + for (ChangesContainer cacheChange : containers) + { + cacheChange.apply(); + } + } + finally + { + changesList.set(null); + changesContainer = null; + } + } + + /** + * Forget about changes + */ + public void rollbackTransaction() + { + changesList.set(null); + } + + /** + * Creates all ChangesBuffers with given parameter + * + * @param local + */ + public void setLocal(boolean local) + { + // start local transaction + if (local && changesList.get() == null) + { + beginTransaction(); + } + if (!local && this.local.get()) + { + + } + this.local.set(local); + } + + /** + * Tries to get buffer and if it is null throws an exception otherwise returns buffer. + * + * @return + */ + private CompressedISPNChangesBuffer getChangesBufferSafe() + { + CompressedISPNChangesBuffer changesContainer = changesList.get(); + if (changesContainer == null) + { + throw new IllegalStateException("changesContainer should not be empty"); + } + return changesContainer; + } + + /** + * + * @param key + * @param value + */ + public void addToList(CacheKey key, Object value) + { + CompressedISPNChangesBuffer changesContainer = getChangesBufferSafe(); + changesContainer.add(new AddToListContainer(key, value, parentCache, changesContainer.getHistoryIndex(), local + .get(), useExpiration, expirationTimeOut)); + } + + /** + * + * @param string + * @param node + * @return + */ + public Object putInBuffer(CacheKey key, Object value) + { + CompressedISPNChangesBuffer changesContainer = getChangesBufferSafe(); + + // take Object from buffer for first + Object prevObject = getObjectFromChangesContainer(changesContainer, key); + + changesContainer.add(new PutObjectContainer(key, value, parentCache, changesContainer.getHistoryIndex(), local + .get(), useExpiration, expirationTimeOut)); + + if (prevObject != null) + { + return prevObject; + } + else + { + return parentCache.get(key); + } + } + + private Object getObjectFromChangesContainer(CompressedISPNChangesBuffer changesContainer, CacheKey key) + { + List<ChangesContainer> changes = changesContainer.getSortedList(); + Object object = null; + + for (ChangesContainer change : changes) + { + if (change.getChangesType().equals(ChangesType.PUT) && change.getKey().equals(key)) + { + object = ((PutObjectContainer)change).value; + } + } + + return object; + } + + /** + * + * @param key + * @param value + */ + public void removeFromList(CacheKey key, Object value) + { + CompressedISPNChangesBuffer changesContainer = getChangesBufferSafe(); + changesContainer.add(new RemoveFromListContainer(key, value, parentCache, changesContainer.getHistoryIndex(), + local.get(), useExpiration, expirationTimeOut)); + } + + public Object getFromBuffer(CacheKey key) + { + //look at buffer for first + CompressedISPNChangesBuffer changesContainer = getChangesBufferSafe(); + + Object objectFromBuffer = getObjectFromChangesContainer(changesContainer, key); + + if (objectFromBuffer != null) + { + return objectFromBuffer; + } + else + { + return parentCache.get(key); + } + } +} Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheId.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheId.java (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheId.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2009 eXo Platform SAS. + * + * This 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 software 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 this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan; + +/** + * + * @author <a href=&quot;anatoliy.bazko(a)exoplatform.org&quot;&gt;Anatoliy Bazko</a> + * @version $Id: CacheId.java 111 2010-11-11 11:11:11Z tolusha $ + */ +public class CacheId extends CacheKey +{ + + /** + * CacheId constructor. + * + * @param id + */ + CacheId(String id) + { + super(id); + } + + /** + * {@inheritDoc} + */ + @Override + public boolean equals(Object obj) + { + if (obj instanceof CacheId) + { + CacheId cacheId = (CacheId)obj; + return (cacheId.hash == hash && cacheId.id.equals(id)); + } + else + { + return false; + } + } +} Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheKey.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheKey.java (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheKey.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2009 eXo Platform SAS. + * + * This 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 software 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 this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan; + +import java.io.Serializable; + +/** + * Created by The eXo Platform SAS. <br/> + * + * Base class for WorkspaceCache keys.<br/> + * + * Date: 10.06.2008<br/> + * + * @author <a href="mailto:peter.nedonosko@exoplatform.com.ua">Peter Nedonosko</a> + * @version $Id: CacheKey.java 34801 2009-07-31 15:44:50Z dkatayev $ + */ +public abstract class CacheKey implements Serializable, Comparable<CacheKey> +{ + + protected final String id; + + protected final int hash; + + CacheKey(String id) + { + this.id = id; + this.hash = id.hashCode(); + } + + /** + * {@inheritDoc} + */ + @Override + public int hashCode() + { + return this.hash; + } + + /** + * {@inheritDoc} + */ + @Override + public String toString() + { + return this.id.toString(); + } + + /** + * {@inheritDoc} + */ + @Override + public int compareTo(CacheKey o) + { + return id.compareTo(o.id); + } +} Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheNodesId.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheNodesId.java (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheNodesId.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2009 eXo Platform SAS. + * + * This 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 software 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 this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan; + +/** + * Created by The eXo Platform SAS + * + * Date: 10.06.2008 + * + * Cache record used to store item Id key. + * + * @author <a href="mailto:peter.nedonosko@exoplatform.com.ua">Peter Nedonosko</a> + * @version $Id: CacheId.java 34801 2009-07-31 15:44:50Z dkatayev $ + */ +public class CacheNodesId extends CacheKey +{ + + public static final String PREFIX = "N"; + + CacheNodesId(String id) + { + super(PREFIX + id); + } + + @Override + public boolean equals(Object obj) + { + if (obj instanceof CacheNodesId) + { + CacheNodesId cacheNodesId = (CacheNodesId)obj; + return (cacheNodesId.hash == hash && cacheNodesId.id.equals(id)); + } + else + { + return false; + } + } + + // check is this descendant of prevRootPath + +} Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CachePropsId.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CachePropsId.java (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CachePropsId.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2009 eXo Platform SAS. + * + * This 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 software 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 this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan; + +/** + * Created by The eXo Platform SAS + * + * Date: 10.06.2008 + * + * Cache record used to store item Id key. + * + * @author <a href="mailto:peter.nedonosko@exoplatform.com.ua">Peter Nedonosko</a> + * @version $Id: CacheId.java 34801 2009-07-31 15:44:50Z dkatayev $ + */ +public class CachePropsId extends CacheKey +{ + + public static final String PREFIX = "P"; + + CachePropsId(String id) + { + super(PREFIX + id); + } + + @Override + public boolean equals(Object obj) + { + if (obj instanceof CachePropsId) + { + CachePropsId cachePropsId = (CachePropsId)obj; + return (cachePropsId.hash == hash && cachePropsId.id.equals(id)); + } + else + { + return false; + } + } +} Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheQPath.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheQPath.java (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CacheQPath.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2009 eXo Platform SAS. + * + * This 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 software 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 this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan; + +import org.exoplatform.services.jcr.datamodel.QPath; +import org.exoplatform.services.jcr.datamodel.QPathEntry; +import org.exoplatform.services.jcr.impl.Constants; + +/** + * Created by The eXo Platform SAS. <br/> + * + * Store QPath as key in cache. + * + * 15.06.07 + * + * @author <a href="mailto:peter.nedonosko@exoplatform.com.ua">Peter Nedonosko</a> + * @version $Id: CacheQPath.java 13869 2008-05-05 08:40:10Z pnedonosko $ + */ +class CacheQPath extends CacheKey +{ + + private final String parentId; + + private final QPath path; + + CacheQPath(String parentId, QPath path) + { + super((parentId != null ? parentId : Constants.ROOT_PARENT_UUID) + + path.getEntries()[path.getEntries().length - 1].getAsString(true)); + + this.parentId = parentId; + this.path = path; + } + + CacheQPath(String parentId, QPathEntry name) + { + super((parentId != null ? parentId : Constants.ROOT_PARENT_UUID) + name.getAsString(true)); + + this.parentId = parentId; + this.path = null; + } + + @Override + public boolean equals(Object obj) + { + if (obj instanceof CacheQPath) + { + CacheQPath cacheQPath = (CacheQPath)obj; + return (cacheQPath.hashCode() == hash && cacheQPath.id.equals(id)); + } + else + { + return false; + } + } + + @Override + public String toString() + { + final StringBuilder s = new StringBuilder(); + s.append((this.parentId != null ? this.parentId : Constants.ROOT_PARENT_UUID)); + s.append((path != null ? path.getEntries()[path.getEntries().length - 1] : "null")); + s.append(", "); + s.append(id); + return s.toString(); + } + +} Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CompressedISPNChangesBuffer.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CompressedISPNChangesBuffer.java (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/CompressedISPNChangesBuffer.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2010 eXo Platform SAS. + * + * This 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 software 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 this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan; + +import org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan.BufferedISPNCache.ChangesContainer; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Sorting cache modification + * + * @author <a href=&quot;anatoliy.bazko(a)exoplatform.org&quot;&gt;Anatoliy Bazko</a> + * @version $Id: CompressedISPNChangesBuffer.java 111 2010-11-11 11:11:11Z tolusha $ + */ +public class CompressedISPNChangesBuffer +{ + private int historyIndex = 0; + + List<ChangesContainer> changes = new ArrayList<ChangesContainer>(); + + /** + * Adds new modification container to buffer and performs optimization if needed. Optimization doesn't iterate + * over lists and uses HashMaps. So each optimization duration doesn't depend on list size. + * + * @param container + */ + public void add(ChangesContainer container) + { + changes.add(container); + } + + /** + * After each invocation of the method increments internal field. + * Designed to be used as history order index in each {@link ChangesContainer} + * @return + */ + public int getHistoryIndex() + { + historyIndex++; + return historyIndex; + } + + /** + * Builds single list of modifications from internal structures and sorts it. + * + * @return + */ + public List<ChangesContainer> getSortedList() + { + List<ChangesContainer> changesContainers = new ArrayList<ChangesContainer>(changes); + Collections.sort(changesContainers); + return changesContainers; + } + +} Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/ISPNCacheWorkspaceStorageCache.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/ISPNCacheWorkspaceStorageCache.java (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/dataflow/persistent/infinispan/ISPNCacheWorkspaceStorageCache.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,913 @@ +/* + * Copyright (C) 2009 eXo Platform SAS. + * + * This 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 software 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 this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan; + +import org.exoplatform.container.configuration.ConfigurationManager; +import org.exoplatform.services.jcr.access.AccessControlList; +import org.exoplatform.services.jcr.config.RepositoryConfigurationException; +import org.exoplatform.services.jcr.config.WorkspaceEntry; +import org.exoplatform.services.jcr.dataflow.ItemState; +import org.exoplatform.services.jcr.dataflow.ItemStateChangesLog; +import org.exoplatform.services.jcr.dataflow.persistent.WorkspaceStorageCache; +import org.exoplatform.services.jcr.datamodel.IllegalPathException; +import org.exoplatform.services.jcr.datamodel.InternalQName; +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.QPath; +import org.exoplatform.services.jcr.datamodel.QPathEntry; +import org.exoplatform.services.jcr.impl.Constants; +import org.exoplatform.services.jcr.impl.dataflow.TransientNodeData; +import org.exoplatform.services.jcr.impl.dataflow.TransientPropertyData; +import org.exoplatform.services.jcr.infinispan.InfinispanCacheFactory; +import org.exoplatform.services.log.ExoLogger; +import org.exoplatform.services.log.Log; +import org.exoplatform.services.transaction.TransactionService; +import org.infinispan.Cache; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Set; + +import javax.jcr.RepositoryException; + +/** + * Created by The eXo Platform SAS.<p/> + * + * Cache based on Infinispan.<p/> + * + * TODO: structure + * + * <ul> + * <li>cache transparent: or item cached or not, we should not generate "not found" Exceptions </li> + * + * <p/> + * Current state notes (subject of change): + * <ul> + * <li>cache implements WorkspaceStorageCache, without any stuff about references and locks</li> + * <li>transaction style implemented via JBC barches, do with JTA (i.e. via exo's TransactionService + JBoss TM)</li> + * </ul> + * + * @author <a href=&quot;anatoliy.bazko(a)exoplatform.org&quot;&gt;Anatoliy Bazko</a> + * @version $Id: ISPNCacheWorkspaceStorageCache.java 111 2010-11-11 11:11:11Z tolusha $ + */ +public class ISPNCacheWorkspaceStorageCache implements WorkspaceStorageCache +{ + + private static final Log LOG = ExoLogger.getLogger("exo.jcr.component.core.ISPNCacheWorkspaceStorageCache"); + + public static final String JBOSSCACHE_CONFIG = "infinispan-configuration"; + + protected final BufferedISPNCache cache; + + /** + * Node order comparator for getChildNodes(). + */ + class NodesOrderComparator<N extends NodeData> implements Comparator<NodeData> + { + + /** + * {@inheritDoc} + */ + public int compare(NodeData n1, NodeData n2) + { + return n1.getOrderNumber() - n2.getOrderNumber(); + } + } + + class ChildItemsIterator<T extends ItemData> implements Iterator<T> + { + + final Iterator<String> childs; + + T next; + + ChildItemsIterator(CacheKey key) + { + Set<String> set = (Set<String>)cache.get(key); + if (set != null) + { + childs = ((Set<String>)cache.get(key)).iterator(); + fetchNext(); + } + else + { + childs = null; + next = null; + } + } + + protected void fetchNext() + { + if (childs.hasNext()) + { + // traverse to the first existing or the end of children + T n = null; + do + { + n = (T)cache.get(new CacheId(childs.next())); + } + while (n == null && childs.hasNext()); + next = n; + } + else + { + next = null; + } + } + + public boolean hasNext() + { + return next != null; + } + + public T next() + { + if (next == null) + { + throw new NoSuchElementException(); + } + + final T current = next; + fetchNext(); + return current; + } + + public void remove() + { + throw new IllegalArgumentException("Not implemented"); + } + } + + class ChildNodesIterator<N extends NodeData> extends ChildItemsIterator<N> + { + ChildNodesIterator(String parentId) + { + super(new CacheNodesId(parentId)); + } + + @Override + public N next() + { + return super.next(); + } + } + + class ChildPropertiesIterator<P extends PropertyData> extends ChildItemsIterator<P> + { + + ChildPropertiesIterator(String parentId) + { + super(new CachePropsId(parentId)); + } + + @Override + public P next() + { + return super.next(); + } + } + + /** + * Cache constructor with eXo TransactionService support. + * + * @param wsConfig WorkspaceEntry workspace config + * @param transactionService TransactionService external transaction service + * @throws RepositoryException if error of initialization + * @throws RepositoryConfigurationException if error of configuration + */ + public ISPNCacheWorkspaceStorageCache(WorkspaceEntry wsConfig, TransactionService transactionService, + ConfigurationManager cfm) throws RepositoryException, RepositoryConfigurationException + { + if (wsConfig.getCache() == null) + { + throw new RepositoryConfigurationException("Cache configuration not found"); + } + + // create cache using custom factory + InfinispanCacheFactory<Serializable, Object> factory = new InfinispanCacheFactory<Serializable, Object>(cfm); + + // create parent JBossCache instance + Cache<Serializable, Object> parentCache = factory.createCache(wsConfig.getCache()); + + // // get all eviction configurations + // List<EvictionRegionConfig> evictionConfigurations = + // parentCache.getConfiguration().getEvictionConfig().getEvictionRegionConfigs(); + // // append and default eviction configuration, since it is not present in region configurations + // evictionConfigurations.add(parentCache.getConfiguration().getEvictionConfig().getDefaultEvictionRegionConfig()); + // + // boolean useExpiration = false; + // // looking over all eviction configurations till the end or till some expiration algorithm subclass not found. + // for (EvictionRegionConfig evictionRegionConfig : evictionConfigurations) + // { + // if (evictionRegionConfig.getEvictionAlgorithmConfig() instanceof ExpirationAlgorithmConfig) + // { + // // force set expiration key to default value in all Expiration configurations (if any) + // ((ExpirationAlgorithmConfig)evictionRegionConfig.getEvictionAlgorithmConfig()) + // .setExpirationKeyName(ExpirationAlgorithmConfig.EXPIRATION_KEY); + // useExpiration = true; + // } + // } + + // if expiration is used, set appropriate factory with with timeout set via configuration (or default one 15minutes) + this.cache = new BufferedISPNCache(parentCache, false, -1); + } + + /** + * Cache constructor with JBossCache JTA transaction support. + * + * @param wsConfig WorkspaceEntry workspace config + * @throws RepositoryException if error of initialization + * @throws RepositoryConfigurationException if error of configuration + */ + public ISPNCacheWorkspaceStorageCache(WorkspaceEntry wsConfig, ConfigurationManager cfm) throws RepositoryException, + RepositoryConfigurationException + { + this(wsConfig, null, cfm); + } + + /** + * {@inheritDoc} + */ + public void put(ItemData item) + { + boolean inTransaction = cache.isTransactionActive(); + try + { + if (!inTransaction) + { + cache.beginTransaction(); + } + cache.setLocal(true); + if (item.isNode()) + { + putNode((NodeData)item, ModifyChildOption.NOT_MODIFY); + } + else + { + putProperty((PropertyData)item, ModifyChildOption.NOT_MODIFY); + } + } + finally + { + cache.setLocal(false); + if (!inTransaction) + { + cache.commitTransaction(); + } + } + } + + /** + * {@inheritDoc} + */ + public void remove(ItemData item) + { + removeItem(item); + } + + /** + * {@inheritDoc} + */ + public void onSaveItems(final ItemStateChangesLog itemStates) + { + // if something happen we will rollback changes + boolean rollback = true; + try + { + cache.beginTransaction(); + for (ItemState state : itemStates.getAllStates()) + { + if (state.isAdded()) + { + if (state.isPersisted()) + { + putItem(state.getData()); + } + } + else if (state.isUpdated()) + { + if (state.isPersisted()) + { + // There was a problem with removing a list of samename siblings in on transaction, + // so putItemInBufferedCache(..) and updateInBufferedCache(..) used instead put(..) and update (..) methods. + ItemData prevItem = putItemInBufferedCache(state.getData()); + if (prevItem != null && state.isNode()) + { + // nodes reordered, if previous is null it's InvalidItemState case + updateInBuffer((NodeData)state.getData(), (NodeData)prevItem); + } + } + } + else if (state.isDeleted()) + { + removeItem(state.getData()); + } + else if (state.isRenamed()) + { + putItem(state.getData()); + } + else if (state.isMixinChanged()) + { + if (state.isPersisted()) + { + // update subtree ACLs + updateMixin((NodeData)state.getData()); + } + } + } + + cache.commitTransaction(); + rollback = false; + } + finally + { + if (rollback) + { + cache.rollbackTransaction(); + } + } + } + + /** + * {@inheritDoc} + */ + public void addChildNodes(NodeData parent, List<NodeData> childs) + { + boolean inTransaction = cache.isTransactionActive(); + try + { + if (!inTransaction) + { + cache.beginTransaction(); + } + + cache.setLocal(true); + + // remove previous all (to be sure about consistency) + cache.remove(new CacheNodesId(parent.getIdentifier())); + + if (childs.size() > 0) + { + Set<Object> set = new HashSet<Object>(); + for (NodeData child : childs) + { + putNode(child, ModifyChildOption.NOT_MODIFY); + set.add(child.getIdentifier()); + } + cache.put(new CacheNodesId(parent.getIdentifier()), set); + } + else + { + // cache fact of empty childs list + cache.put(new CacheNodesId(parent.getIdentifier()), new HashSet<Object>()); + } + } + finally + { + cache.setLocal(false); + if (!inTransaction) + { + cache.commitTransaction(); + } + } + } + + /** + * {@inheritDoc} + */ + public void addChildProperties(NodeData parent, List<PropertyData> childs) + { + boolean inTransaction = cache.isTransactionActive(); + try + { + if (!inTransaction) + { + cache.beginTransaction(); + } + cache.setLocal(true); + // remove previous all (to be sure about consistency) + cache.remove(new CachePropsId(parent.getIdentifier())); + if (childs.size() > 0) + { + // add all new + Set<Object> set = new HashSet<Object>(); + for (PropertyData child : childs) + { + putProperty(child, ModifyChildOption.NOT_MODIFY); + set.add(child.getIdentifier()); + } + cache.put(new CachePropsId(parent.getIdentifier()), set); + + } + else + { + LOG.warn("Empty properties list cached " + (parent != null ? parent.getQPath().getAsString() : parent)); + } + } + finally + { + cache.setLocal(false); + if (!inTransaction) + { + cache.commitTransaction(); + } + } + } + + /** + * {@inheritDoc} + */ + public void addChildPropertiesList(NodeData parent, List<PropertyData> childProperties) + { + // TODO not implemented, will force read from DB + // try + // { + // cache.beginTransaction(); + // cache.setLocal(true); + // + // } + // finally + // { + // cache.setLocal(false); + // cache.commitTransaction(); + // } + } + + /** + * {@inheritDoc} + */ + public ItemData get(String parentId, QPathEntry name) + { + return (ItemData)cache.get(new CacheQPath(parentId, name)); + } + + /** + * {@inheritDoc} + */ + public ItemData get(String id) + { + return id == null ? null : (ItemData)cache.get(new CacheId(id)); + } + + /** + * {@inheritDoc} + */ + public List<NodeData> getChildNodes(final NodeData parent) + { + // get list of children uuids + final Set<String> set = (Set<String>)cache.get(new CacheNodesId(parent.getIdentifier())); + + if (set != null) + { + final List<NodeData> childs = new ArrayList<NodeData>(); + + for (String childId : set) + { + NodeData child = (NodeData)cache.get(new CacheId(childId)); + if (child == null) + { + return null; + } + + childs.add(child); + } + + // order children by orderNumber, as HashSet returns children in other order + Collections.sort(childs, new NodesOrderComparator<NodeData>()); + + return childs; + } + else + { + return null; + } + } + + /** + * {@inheritDoc} + */ + public int getChildNodesCount(NodeData parent) + { + Set<String> list = (Set<String>)cache.get(new CacheNodesId(parent.getIdentifier())); + return list != null ? list.size() : -1; + } + + /** + * {@inheritDoc} + */ + public List<PropertyData> getChildProperties(NodeData parent) + { + return getChildProps(parent.getIdentifier(), true); + } + + /** + * {@inheritDoc} + */ + public List<PropertyData> listChildProperties(NodeData parent) + { + return getChildProps(parent.getIdentifier(), false); + } + + /** + * Internal get child properties. + * + * @param parentId String + * @param withValue boolean, if true only "full" Propeties can be returned + * @return List of PropertyData + */ + protected List<PropertyData> getChildProps(String parentId, boolean withValue) + { + // get list of children uuids + final Set<String> set = (Set<String>)cache.get(new CachePropsId(parentId)); + if (set != null) + { + final List<PropertyData> childs = new ArrayList<PropertyData>(); + + for (String childId : set) + { + PropertyData child = (PropertyData)cache.get(new CacheId(childId)); + + if (child == null) + { + return null; + } + if (withValue && child.getValues().size() <= 0) + { + return null; + } + childs.add(child); + } + return childs; + } + else + { + return null; + } + } + + /** + * {@inheritDoc} + */ + public long getSize() + { + return cache.size(); + } + + /** + * {@inheritDoc} + */ + public boolean isEnabled() + { + return true; + } + + /** + * Internal put Item. + * + * @param item ItemData, new data to put in the cache + * @return ItemData, previous data or null + */ + protected ItemData putItem(ItemData item) + { + if (item.isNode()) + { + return putNode((NodeData)item, ModifyChildOption.MODIFY); + } + else + { + return putProperty((PropertyData)item, ModifyChildOption.MODIFY); + } + } + + protected ItemData putItemInBufferedCache(ItemData item) + { + if (item.isNode()) + { + return putNodeInBufferedCache((NodeData)item, ModifyChildOption.MODIFY); + } + else + { + return putProperty((PropertyData)item, ModifyChildOption.MODIFY); + } + + } + + /** + * Internal put Node. + * + * @param node, NodeData, new data to put in the cache + * @return NodeData, previous data or null + */ + protected ItemData putNode(NodeData node, ModifyChildOption modifyListsOfChild) + { + if (node.getParentIdentifier() != null) + { + // if MODIFY and List present OR FORCE_MODIFY, then write + if ((modifyListsOfChild == ModifyChildOption.MODIFY && cache.get(new CacheNodesId(node.getParentIdentifier())) != null) + || modifyListsOfChild == ModifyChildOption.FORCE_MODIFY) + { + cache.addToList(new CacheNodesId(node.getParentIdentifier()), node.getIdentifier()); + } + } + + cache.put(new CacheQPath(node.getParentIdentifier(), node.getQPath()), node); + return (ItemData)cache.put(new CacheId(node.getIdentifier()), node); + } + + protected ItemData putNodeInBufferedCache(NodeData node, ModifyChildOption modifyListsOfChild) + { + if (node.getParentIdentifier() != null) + { + // if MODIFY and List present OR FORCE_MODIFY, then write + if ((modifyListsOfChild == ModifyChildOption.MODIFY && cache.get(new CacheNodesId(node.getParentIdentifier())) != null) + || modifyListsOfChild == ModifyChildOption.FORCE_MODIFY) + { + cache.addToList(new CacheNodesId(node.getParentIdentifier()), node.getIdentifier()); + } + } + + cache.putInBuffer(new CacheQPath(node.getParentIdentifier(), node.getQPath()), node); + return (ItemData)cache.putInBuffer(new CacheId(node.getIdentifier()), node); + } + + /** + * Internal put Property. + * + * @param node, PropertyData, new data to put in the cache + * @return PropertyData, previous data or null + */ + protected PropertyData putProperty(PropertyData prop, ModifyChildOption modifyListsOfChild) + { + // if MODIFY and List present OR FORCE_MODIFY, then write + if ((modifyListsOfChild == ModifyChildOption.MODIFY && cache.get(new CachePropsId(prop.getParentIdentifier())) != null) + || modifyListsOfChild == ModifyChildOption.FORCE_MODIFY) + { + cache.addToList(new CachePropsId(prop.getParentIdentifier()), prop.getIdentifier()); + } + + cache.put(new CacheQPath(prop.getParentIdentifier(), prop.getQPath()), prop); + return (PropertyData)cache.put(new CacheId(prop.getIdentifier()), prop); + } + + protected void removeItem(ItemData item) + { + cache.remove(new CacheId(item.getIdentifier())); + cache.remove(new CacheQPath(item.getParentIdentifier(), item.getQPath())); + + if (item.getParentIdentifier() != null) + { + if (item.isNode()) + { + cache.removeFromList(new CacheNodesId(item.getParentIdentifier()), item.getIdentifier()); + } + else + { + cache.removeFromList(new CachePropsId(item.getParentIdentifier()), item.getIdentifier()); + } + } + } + + /** + * Update Node's mixin and ACL. + * + * @param node NodeData + */ + protected void updateMixin(NodeData node) + { + NodeData prevData = (NodeData)cache.put(new CacheId(node.getIdentifier()), node); + cache.put(new CacheQPath(node.getParentIdentifier(), node.getQPath()), node); + + if (prevData != null) + { + // do update ACL if needed + if (prevData.getACL() == null || !prevData.getACL().equals(node.getACL())) + { + updateChildsACL(node.getIdentifier(), node.getACL()); + } + } + else if (LOG.isDebugEnabled()) + { + LOG.debug("Previous NodeData not found for mixin update " + node.getQPath().getAsString()); + } + } + + /** + * Update Node hierachy in case of same-name siblings reorder. + * Assumes the new (updated) nodes already putted in the cache. Previous name of updated nodes will be calculated + * and that node will be deleted (if has same id as the new node). Childs paths will be updated to a new node path. + * + * @param node NodeData + * @param prevNode NodeData + */ + protected void updateInBuffer(final NodeData node, final NodeData prevNode) + { + // Fqn<String> prevFqn = + // makeChildFqn(childNodes, node.getParentIdentifier(), prevNode.getQPath().getEntries()[prevNode.getQPath() + // .getEntries().length - 1]); + // + // if (node.getIdentifier().equals(cache.getFromBuffer(prevFqn, ITEM_ID))) + // { + // // it's same-name siblings re-ordering, delete previous child + // if (!cache.removeNode(prevFqn) && LOG.isDebugEnabled()) + // { + // LOG.debug("Node not extists as a child but update asked " + node.getQPath().getAsString()); + // } + // } + + // update childs paths if index changed + int nodeIndex = node.getQPath().getEntries()[node.getQPath().getEntries().length - 1].getIndex(); + int prevNodeIndex = prevNode.getQPath().getEntries()[prevNode.getQPath().getEntries().length - 1].getIndex(); + if (nodeIndex != prevNodeIndex) + { + // its a samename reordering + updateTreePath(prevNode.getQPath(), node.getQPath(), null); // don't change ACL, it's same parent + } + } + + /** + * Check all items in cache - is it descendant of prevRootPath, and update path according newRootPath. + * + * @param prevRootPath + * @param newRootPath + * @param acl + */ + protected void updateTreePath(final QPath prevRootPath, final QPath newRootPath, final AccessControlList acl) + { + boolean inheritACL = acl != null; + + // check all ITEMS in cache + Iterator<Serializable> keys = cache.keySet().iterator(); + + while (keys.hasNext()) + { + CacheKey key = (CacheKey)keys.next(); + if (key instanceof CacheId || key instanceof CacheQPath) + { + ItemData data = (ItemData)cache.get(key); + + if (data != null) + { + // check is this descendant of prevRootPath + QPath nodeQPath = data.getQPath(); + if (nodeQPath.isDescendantOf(prevRootPath)) + { + + //make relative path + QPathEntry[] relativePath = null; + try + { + relativePath = nodeQPath.getRelPath(nodeQPath.getDepth() - prevRootPath.getDepth()); + } + catch (IllegalPathException e) + { + // Do nothing. Never happens. + } + + // make new path - no matter node or property + QPath newPath = QPath.makeChildPath(newRootPath, relativePath); + + if (data.isNode()) + { + // update node + NodeData prevNode = (NodeData)data; + + TransientNodeData newNode = + new TransientNodeData(newPath, prevNode.getIdentifier(), prevNode.getPersistedVersion(), + prevNode.getPrimaryTypeName(), prevNode.getMixinTypeNames(), prevNode.getOrderNumber(), + prevNode.getParentIdentifier(), inheritACL ? acl : prevNode.getACL()); // TODO check ACL + + // update this node + if (key instanceof CacheId) + { + cache.put(new CacheId(newNode.getIdentifier()), newNode); + } + else + { + cache.put(new CacheQPath(newNode.getParentIdentifier(), newNode.getQPath()), newNode); + } + } + else + { + //update property + PropertyData prevProp = (PropertyData)data; + + if (inheritACL + && (prevProp.getQPath().getName().equals(Constants.EXO_PERMISSIONS) || prevProp.getQPath() + .getName().equals(Constants.EXO_OWNER))) + { + inheritACL = false; + } + + TransientPropertyData newProp = + new TransientPropertyData(newPath, prevProp.getIdentifier(), prevProp.getPersistedVersion(), + prevProp.getType(), prevProp.getParentIdentifier(), prevProp.isMultiValued(), prevProp + .getValues()); + + // update this property + if (key instanceof CacheId) + { + cache.put(new CacheId(newProp.getIdentifier()), newProp); + } + else + { + cache.put(new CacheQPath(newProp.getParentIdentifier(), newProp.getQPath()), newProp); + } + } + } + } + } + } + } + + /** + * Update child Nodes ACLs. + * + * @param parentId String - root node id of JCR subtree. + * @param acl AccessControlList + */ + protected void updateChildsACL(final String parentId, final AccessControlList acl) + { + for (Iterator<NodeData> iter = new ChildNodesIterator<NodeData>(parentId); iter.hasNext();) + { + NodeData prevNode = iter.next(); + + // is ACL changes on this node (i.e. ACL inheritance brokes) + for (InternalQName mixin : prevNode.getMixinTypeNames()) + { + if (mixin.equals(Constants.EXO_PRIVILEGEABLE) || mixin.equals(Constants.EXO_OWNEABLE)) + { + continue; + } + } + + // recreate with new path for child Nodes only + TransientNodeData newNode = + new TransientNodeData(prevNode.getQPath(), prevNode.getIdentifier(), prevNode.getPersistedVersion(), + prevNode.getPrimaryTypeName(), prevNode.getMixinTypeNames(), prevNode.getOrderNumber(), prevNode + .getParentIdentifier(), acl); + + // update this node + cache.put(new CacheId(newNode.getIdentifier()), newNode); + cache.put(new CacheQPath(newNode.getIdentifier(), newNode.getQPath()), newNode); + + // update childs recursive + updateChildsACL(newNode.getIdentifier(), acl); + } + } + + public void beginTransaction() + { + cache.beginTransaction(); + } + + public void commitTransaction() + { + cache.commitTransaction(); + } + + public void rollbackTransaction() + { + cache.rollbackTransaction(); + } + + /** + * {@inheritDoc} + */ + public boolean isTXAware() + { + return true; + } + + /** + * <li>NOT_MODIFY - node(property) is not added to the parent's list (no persistent changes performed, cache used as cache)</li> + * <li>MODIFY - node(property) is added to the parent's list if parent in the cache (new item is added to persistent, add to list if it is present)</li> + * <li>FORCE_MODIFY - node(property) is added to the parent's list anyway (when list is read from DB, forcing write)</li> + */ + private enum ModifyChildOption { + NOT_MODIFY, MODIFY, FORCE_MODIFY + } + +} Modified: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/util/io/PrivilegedCacheHelper.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/util/io/PrivilegedCacheHelper.java 2010-07-30 11:40:38 UTC (rev 2842) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/util/io/PrivilegedCacheHelper.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -236,4 +236,42 @@ } } } + + /** + * Put in Infinispan cache in privileged mode. + * + * @param cache + */ + public static Object put(final org.infinispan.Cache<Serializable, Object> cache, final Serializable key, + final Object value) throws CacheException + { + PrivilegedExceptionAction<Object> action = new PrivilegedExceptionAction<Object>() + { + public Object run() throws Exception + { + return cache.put(key, value); + } + }; + try + { + return AccessController.doPrivileged(action); + } + catch (PrivilegedActionException pae) + { + Throwable cause = pae.getCause(); + if (cause instanceof CacheException) + { + throw (CacheException)cause; + } + else if (cause instanceof RuntimeException) + { + throw (RuntimeException)cause; + } + else + { + throw new RuntimeException(cause); + } + } + } + } 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-30 11:40:38 UTC (rev 2842) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/infinispan/InfinispanCacheFactory.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -52,8 +52,6 @@ public static final String INFINISPAN_CONFIG = "infinispan-configuration"; - public static final String INFINISPAN_CACHE_NAME = "infinispan-cache-name"; - public static final String JGROUPS_CONFIG = "jgroups-configuration"; public static final String JGROUPS_MUX_ENABLED = "jgroups-multiplexer-stack"; @@ -78,9 +76,8 @@ /** * Factory that creates and starts pre-configured instances of Infinispan. - * Path to Infinispan configuration or template and cache name should be - * provided as "infinispan-configuration" and "infinispan-cache-name" properties - * in parameterEntry instance respectively. + * Path to Infinispan configuration or template should be provided as + * "infinispan-configuration" property in parameterEntry instance. * <br> * If parameterEntry has "jgroups-multiplexer-stack" (=true) and * "jgroups-configuration" parameters then Multiplexing stack is enabled @@ -94,8 +91,7 @@ { // get Infinispan configuration file path and cache name final String configurationPath = parameterEntry.getParameterValue(INFINISPAN_CONFIG); - final String cacheName = parameterEntry.getParameterValue(INFINISPAN_CACHE_NAME); - log.info("Infinispan Cache configuration used: " + configurationPath + " cache name: " + cacheName); + log.info("Infinispan Cache configuration used: " + configurationPath); // prepare configuration InputStream configStream; @@ -124,7 +120,7 @@ { public Cache<K, V> run() { - return manager.getCache(cacheName); + return manager.getCache(); } }; Cache<K, V> cache = AccessController.doPrivileged(action); Modified: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/java/org/exoplatform/services/jcr/api/writing/TestOrderBefore.java =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/java/org/exoplatform/services/jcr/api/writing/TestOrderBefore.java 2010-07-30 11:40:38 UTC (rev 2842) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/java/org/exoplatform/services/jcr/api/writing/TestOrderBefore.java 2010-07-30 13:00:43 UTC (rev 2843) @@ -25,7 +25,6 @@ import java.util.List; import javax.jcr.ItemExistsException; -import javax.jcr.ItemNotFoundException; import javax.jcr.Node; import javax.jcr.NodeIterator; import javax.jcr.PathNotFoundException; @@ -241,723 +240,723 @@ // -------------- Simple use-case: child nodes n1, n2, n3, n4 --------------- - public void testOrderUp() throws Exception - { - initSimpleCase(); + // public void testOrderUp() throws Exception + // { + // initSimpleCase(); + // + // testBase.orderBefore("n4", "n3"); + // + // String[] order = new String[]{"n1", "n2", "n4", "n3"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // public void testOrderUpStepOver() throws Exception + // { + // initSimpleCase5(); + // + // // was n2,n3,n1,n4,n5 + // testBase.orderBefore("n4", "n3"); + // + // String[] order = new String[]{"n2", "n4", "n3", "n1", "n5"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // public void testOrderBegin() throws Exception + // { + // initSimpleCase(); + // + // testBase.orderBefore("n3", "n1"); + // + // String[] order = new String[]{"n3", "n1", "n2", "n4"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // public void testOrderDown() throws Exception + // { + // initSimpleCase(); + // + // testBase.orderBefore("n2", "n4"); + // + // String[] order = new String[]{"n1", "n3", "n2", "n4"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // public void testOrderEnd() throws Exception + // { + // initSimpleCase(); + // + // testBase.orderBefore("n2", null); + // + // String[] order = new String[]{"n1", "n3", "n4", "n2"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // // ----- Same-name sibling use-case: child nodes n1, n2[1], n2[2], n3 ----- + // + // public void testOrderUp_SNS1() throws Exception + // { + // initSNSCase1(); + // + // testBase.orderBefore("n3", "n2"); + // + // String[] order = new String[]{"n1", "n3", "n2", "n2[2]"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // public void testOrderBegin_SNS1() throws Exception + // { + // initSNSCase1(); + // + // testBase.orderBefore("n2[2]", "n1"); + // + // String[] order = new String[]{"n2", "n1", "n2[2]", "n3"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // public void testOrderDown_SNS1() throws Exception + // { + // initSNSCase1(); + // + // testBase.orderBefore("n1", "n2[2]"); + // + // String[] order = new String[]{"n2", "n1", "n2[2]", "n3"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // /** + // * A childs order map is unchanged after the order + // */ + // public void testOrderDown1_SNS1() throws Exception + // { + // initSNSCase1(); + // + // testBase.orderBefore("n2", "n3"); + // + // String[] order = new String[]{"n1", "n2", "n2[2]", "n3"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // public void testOrderEnd_SNS1() throws Exception + // { + // initSNSCase1(); + // + // testBase.orderBefore("n2[2]", null); + // + // String[] order = new String[]{"n1", "n2", "n3", "n2[2]"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // } + // + // // ----- Same-name sibling use-case: child nodes n1, n1[2], n1[3], n1[4]. + // // n1[3] - + // // mix:referenceable ----- + // + // public void testOrderBegin_SNS2() throws Exception + // { + // initSNSCase2(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n1[3]", "n1"); + // + // String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] + // // -> n1 + // + // checkOrder(order); + // + // try + // { + // String n1uuid = testBase.getNode("n1").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n1uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n1uuid = testBase.getNode("n1").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n1uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1").getPath() + // + ". " + e); + // } + // } + // + // public void testOrderUp_SNS2() throws Exception + // { + // initSNSCase2(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n1[4]", "n1[2]"); + // + // String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] + // // -> + // // n1[4] + // + // checkOrder(order); + // + // try + // { + // String n4uuid = testBase.getNode("n1[4]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n4uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[4]").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n4uuid = testBase.getNode("n1[4]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n4uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[4]").getPath() + // + ". " + e); + // } + // } + // + // public void testOrderDown_SNS2() throws Exception + // { + // initSNSCase2(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n1", "n1[3]"); + // + // String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] + // // is + // // unchanged + // // in + // // location + // + // checkOrder(order); + // + // try + // { + // String n3uuid_same = testBase.getNode("n1[3]").getUUID(); + // assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n3uuid_same = testBase.getNode("n1[3]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n3uuid_same); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[3]").getPath() + // + ". " + e); + // } + // } + // + // /** + // * A childs order map is unchanged after the order + // */ + // public void testOrderDown1_SNS2() throws Exception + // { + // initSNSCase2(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n1[2]", "n1[4]"); + // + // String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] + // // -> + // // n1[2] + // + // checkOrder(order); + // + // try + // { + // String n2uuid = testBase.getNode("n1[2]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n2uuid = testBase.getNode("n1[2]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() + // + ". " + e); + // } + // } + // + // public void testOrderEnd_SNS2() throws Exception + // { + // initSNSCase2(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n1[2]", null); + // + // String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] + // // -> + // // n1[2] + // + // checkOrder(order); + // + // try + // { + // String n2uuid = testBase.getNode("n1[2]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n2uuid = testBase.getNode("n1[2]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() + // + ". " + e); + // } + // } + // + // // ----- Same-name sibling use-case: child nodes n1, n1[2], n1[3], n1[4], n2. + // // n1[3] - + // // mix:referenceable ----- + // + // public void testOrderBegin_SNS3() throws Exception + // { + // initSNSCase3(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n2", "n1"); + // + // String[] order = new String[]{"n2", "n1", "n1[2]", "n1[3]", "n1[4]"}; // n1 + // // [ + // // 3 + // // ] + // // unchanged + // + // checkOrder(order); + // + // try + // { + // String n3uuid_same = testBase.getNode("n1[3]").getUUID(); + // assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n3uuid_same = testBase.getNode("n1[3]").getUUID(); + // assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() + // + ". " + e); + // } + // } + // + // public void testOrderUp_SNS3() throws Exception + // { + // initSNSCase3(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n2", "n1[3]"); + // + // String[] order = new String[]{"n1", "n1[2]", "n2", "n1[3]", "n1[4]"}; // n1 + // // [ + // // 3 + // // ] + // // unchanged + // + // checkOrder(order); + // + // try + // { + // String n3uuid_same = testBase.getNode("n1[3]").getUUID(); + // assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n3uuid_same = testBase.getNode("n1[3]").getUUID(); + // assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() + // + ". " + e); + // } + // } + // + // public void testOrderDown_SNS3() throws Exception + // { + // initSNSCase3(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n1", "n2"); + // + // String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]", "n2"}; // n1 + // // [ + // // 3 + // // ] + // // - + // // > + // // n1 + // // [ + // // 2 + // // ] + // + // checkOrder(order); + // + // try + // { + // String n2uuid = testBase.getNode("n1[2]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n2uuid = testBase.getNode("n1[2]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() + // + ". " + e); + // } + // } + // + // /** + // * A childs order map is unchanged after the order + // */ + // public void testOrderDown1_SNS3() throws Exception + // { + // initSNSCase3(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n1[2]", "n1[4]"); + // + // String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]", "n2"}; // n1 + // // [ + // // 3 + // // ] + // // - + // // > + // // n1 + // // [ + // // 2 + // // ] + // + // checkOrder(order); + // + // try + // { + // String n2uuid = testBase.getNode("n1[2]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n2uuid = testBase.getNode("n1[2]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() + // + ". " + e); + // } + // } + // + // public void testOrderEnd_SNS3() throws Exception + // { + // initSNSCase3(); + // + // String n3uuid = testBase.getNode("n1[3]").getUUID(); + // + // testBase.orderBefore("n1[3]", null); + // + // String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n2", "n1[4]"}; // n1 + // // [3]->n1[4] + // + // checkOrder(order); + // + // try + // { + // String n4uuid = testBase.getNode("n1[4]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n4uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[4]").getPath() + // + ". " + e); + // } + // + // testBase.save(); + // + // checkOrderAnotherSession(order); + // + // try + // { + // String n4uuid = testBase.getNode("n1[4]").getUUID(); + // assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n4uuid); + // } + // catch (RepositoryException e) + // { + // fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[4]").getPath() + // + ". " + e); + // } + // } + // + // // ================= Large arrays of nodes ================ + // /** + // * Test of case when an index text length in the item path is differs from one + // * new creted by reorder. E.g. n1[2] -> n1[100] + // */ + // public void testLargeNodesArray() throws Exception + // { + // initSNSCaseLargeArray(); + // + // // String n40uuid = testBase.getNode("n1[40]").getUUID(); + // + // Node n1__2 = testBase.getNode("n1[2]"); + // Node n_21 = testBase.getNode("n_21"); + // Node n_24 = testBase.getNode("n_24"); + // + // // === step 1 === + // + // // n1[2] -> n1[100] pos:120; n_21 = pos:121; ... n1[3] -> pos:2; n1[99] -> + // // n1[98] pos:98; + // // n1[100] -> n1[99] pos:99 + // testBase.orderBefore("n1[2]", "n_21"); + // + // EntityCollection nodes = getEntityCollection(testBase.getNodes()); + // + // assertEquals("Nodes must be equals ", n1__2, nodes.getList().get(119)); // pos + // // : + // // 120 + // assertEquals("Nodes must be equals ", n1__2, testBase.getNode("n1[100]")); + // + // assertEquals("Nodes must be equals ", n_21, nodes.getList().get(120)); //pos: + // // 121 + // assertEquals("Nodes must be equals ", n_21, testBase.getNode("n_21")); + // + // assertTrue("Node must exists ", testBase.hasNode("n1[2]")); + // + // testBase.save(); + // + // nodes = getEntityCollection(testBase.getNodes()); + // + // assertEquals("Nodes must be equals ", n1__2, nodes.getList().get(119)); // pos + // // : + // // 120 + // assertEquals("Nodes must be equals ", n1__2, testBase.getNode("n1[100]")); + // + // assertEquals("Nodes must be equals ", n_21, nodes.getList().get(120)); //pos: + // // 121 + // assertEquals("Nodes must be equals ", n_21, testBase.getNode("n_21")); + // + // assertTrue("Node must exists ", testBase.hasNode("n1[2]")); + // + // // === step 2 === + // + // Node n1__100 = testBase.getNode("n1[100]"); + // + // // n_24 -> pos:120; n1[100] -> pos:121; + // testBase.orderBefore("n_24", "n1[100]"); + // + // nodes = getEntityCollection(testBase.getNodes()); + // + // assertEquals("Nodes must be equals ", n1__100, nodes.getList().get(120)); // pos + // // : + // // 121 + // assertEquals("Nodes must be equals ", n1__100, testBase.getNode("n1[100]")); + // + // assertEquals("Nodes must be equals ", n_24, nodes.getList().get(119)); //pos: + // // 120 + // assertEquals("Nodes must be equals ", n_24, testBase.getNode("n_24")); + // + // assertEquals("Nodes must be equals ", n_21, nodes.getList().get(121)); //pos: + // // 122 + // assertEquals("Nodes must be equals ", n_21, testBase.getNode("n_21")); + // + // testBase.save(); + // + // assertEquals("Nodes must be equals ", n1__100, nodes.getList().get(120)); // pos + // // : + // // 121 + // assertEquals("Nodes must be equals ", n1__100, testBase.getNode("n1[100]")); + // + // assertEquals("Nodes must be equals ", n_24, nodes.getList().get(119)); //pos: + // // 120 + // assertEquals("Nodes must be equals ", n_24, testBase.getNode("n_24")); + // + // assertEquals("Nodes must be equals ", n_21, nodes.getList().get(121)); //pos: + // // 122 + // assertEquals("Nodes must be equals ", n_21, testBase.getNode("n_21")); + // } + // + // public void testOrderTwice() throws Exception + // { + // + // String[] order = new String[]{"n1", "n2", "n3", "n4", "n5"}; + // initCustom(order); + // checkOrder(testBase, order); + // + // testBase.orderBefore("n1", "n4"); + // + // order = new String[]{"n2", "n3", "n1", "n4", "n5"}; + // + // checkOrder(order); + // + // testBase.save(); + // + // checkOrder(order); + // + // checkOrderAnotherSession(order); + // + // testBase.orderBefore("n4", "n3"); + // + // order = new String[]{"n2", "n4", "n3", "n1", "n5"}; + // + // checkOrder(order); + // + // testBase.save(); + // checkOrder(order); + // checkOrderAnotherSession(order); + // + // } - testBase.orderBefore("n4", "n3"); - - String[] order = new String[]{"n1", "n2", "n4", "n3"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - public void testOrderUpStepOver() throws Exception - { - initSimpleCase5(); - - // was n2,n3,n1,n4,n5 - testBase.orderBefore("n4", "n3"); - - String[] order = new String[]{"n2", "n4", "n3", "n1", "n5"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - public void testOrderBegin() throws Exception - { - initSimpleCase(); - - testBase.orderBefore("n3", "n1"); - - String[] order = new String[]{"n3", "n1", "n2", "n4"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - public void testOrderDown() throws Exception - { - initSimpleCase(); - - testBase.orderBefore("n2", "n4"); - - String[] order = new String[]{"n1", "n3", "n2", "n4"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - public void testOrderEnd() throws Exception - { - initSimpleCase(); - - testBase.orderBefore("n2", null); - - String[] order = new String[]{"n1", "n3", "n4", "n2"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - // ----- Same-name sibling use-case: child nodes n1, n2[1], n2[2], n3 ----- - - public void testOrderUp_SNS1() throws Exception - { - initSNSCase1(); - - testBase.orderBefore("n3", "n2"); - - String[] order = new String[]{"n1", "n3", "n2", "n2[2]"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - public void testOrderBegin_SNS1() throws Exception - { - initSNSCase1(); - - testBase.orderBefore("n2[2]", "n1"); - - String[] order = new String[]{"n2", "n1", "n2[2]", "n3"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - public void testOrderDown_SNS1() throws Exception - { - initSNSCase1(); - - testBase.orderBefore("n1", "n2[2]"); - - String[] order = new String[]{"n2", "n1", "n2[2]", "n3"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - /** - * A childs order map is unchanged after the order - */ - public void testOrderDown1_SNS1() throws Exception - { - initSNSCase1(); - - testBase.orderBefore("n2", "n3"); - - String[] order = new String[]{"n1", "n2", "n2[2]", "n3"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - public void testOrderEnd_SNS1() throws Exception - { - initSNSCase1(); - - testBase.orderBefore("n2[2]", null); - - String[] order = new String[]{"n1", "n2", "n3", "n2[2]"}; - - checkOrder(order); - - testBase.save(); - - checkOrderAnotherSession(order); - } - - // ----- Same-name sibling use-case: child nodes n1, n1[2], n1[3], n1[4]. - // n1[3] - - // mix:referenceable ----- - - public void testOrderBegin_SNS2() throws Exception - { - initSNSCase2(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n1[3]", "n1"); - - String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] - // -> n1 - - checkOrder(order); - - try - { - String n1uuid = testBase.getNode("n1").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n1uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n1uuid = testBase.getNode("n1").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n1uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1").getPath() - + ". " + e); - } - } - - public void testOrderUp_SNS2() throws Exception - { - initSNSCase2(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n1[4]", "n1[2]"); - - String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] - // -> - // n1[4] - - checkOrder(order); - - try - { - String n4uuid = testBase.getNode("n1[4]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n4uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[4]").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n4uuid = testBase.getNode("n1[4]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n4uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[4]").getPath() - + ". " + e); - } - } - - public void testOrderDown_SNS2() throws Exception - { - initSNSCase2(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n1", "n1[3]"); - - String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] - // is - // unchanged - // in - // location - - checkOrder(order); - - try - { - String n3uuid_same = testBase.getNode("n1[3]").getUUID(); - assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n3uuid_same = testBase.getNode("n1[3]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n3uuid_same); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[3]").getPath() - + ". " + e); - } - } - - /** - * A childs order map is unchanged after the order - */ - public void testOrderDown1_SNS2() throws Exception - { - initSNSCase2(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n1[2]", "n1[4]"); - - String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] - // -> - // n1[2] - - checkOrder(order); - - try - { - String n2uuid = testBase.getNode("n1[2]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n2uuid = testBase.getNode("n1[2]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() - + ". " + e); - } - } - - public void testOrderEnd_SNS2() throws Exception - { - initSNSCase2(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n1[2]", null); - - String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]"}; // n1[3] - // -> - // n1[2] - - checkOrder(order); - - try - { - String n2uuid = testBase.getNode("n1[2]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n2uuid = testBase.getNode("n1[2]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() - + ". " + e); - } - } - - // ----- Same-name sibling use-case: child nodes n1, n1[2], n1[3], n1[4], n2. - // n1[3] - - // mix:referenceable ----- - - public void testOrderBegin_SNS3() throws Exception - { - initSNSCase3(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n2", "n1"); - - String[] order = new String[]{"n2", "n1", "n1[2]", "n1[3]", "n1[4]"}; // n1 - // [ - // 3 - // ] - // unchanged - - checkOrder(order); - - try - { - String n3uuid_same = testBase.getNode("n1[3]").getUUID(); - assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n3uuid_same = testBase.getNode("n1[3]").getUUID(); - assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() - + ". " + e); - } - } - - public void testOrderUp_SNS3() throws Exception - { - initSNSCase3(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n2", "n1[3]"); - - String[] order = new String[]{"n1", "n1[2]", "n2", "n1[3]", "n1[4]"}; // n1 - // [ - // 3 - // ] - // unchanged - - checkOrder(order); - - try - { - String n3uuid_same = testBase.getNode("n1[3]").getUUID(); - assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n3uuid_same = testBase.getNode("n1[3]").getUUID(); - assertEquals("A UUIDs must be unchanged after order an other node", n3uuid, n3uuid_same); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order of an other node, " + testBase.getNode("n1[3]").getPath() - + ". " + e); - } - } - - public void testOrderDown_SNS3() throws Exception - { - initSNSCase3(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n1", "n2"); - - String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]", "n2"}; // n1 - // [ - // 3 - // ] - // - - // > - // n1 - // [ - // 2 - // ] - - checkOrder(order); - - try - { - String n2uuid = testBase.getNode("n1[2]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n2uuid = testBase.getNode("n1[2]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() - + ". " + e); - } - } - - /** - * A childs order map is unchanged after the order - */ - public void testOrderDown1_SNS3() throws Exception - { - initSNSCase3(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n1[2]", "n1[4]"); - - String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n1[4]", "n2"}; // n1 - // [ - // 3 - // ] - // - - // > - // n1 - // [ - // 2 - // ] - - checkOrder(order); - - try - { - String n2uuid = testBase.getNode("n1[2]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n2uuid = testBase.getNode("n1[2]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n2uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[2]").getPath() - + ". " + e); - } - } - - public void testOrderEnd_SNS3() throws Exception - { - initSNSCase3(); - - String n3uuid = testBase.getNode("n1[3]").getUUID(); - - testBase.orderBefore("n1[3]", null); - - String[] order = new String[]{"n1", "n1[2]", "n1[3]", "n2", "n1[4]"}; // n1 - // [3]->n1[4] - - checkOrder(order); - - try - { - String n4uuid = testBase.getNode("n1[4]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n4uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[4]").getPath() - + ". " + e); - } - - testBase.save(); - - checkOrderAnotherSession(order); - - try - { - String n4uuid = testBase.getNode("n1[4]").getUUID(); - assertEquals("A UUIDs must be equals after order node to another position", n3uuid, n4uuid); - } - catch (RepositoryException e) - { - fail("A node is not mix:referenceable after order to another position, " + testBase.getNode("n1[4]").getPath() - + ". " + e); - } - } - - // ================= Large arrays of nodes ================ - /** - * Test of case when an index text length in the item path is differs from one - * new creted by reorder. E.g. n1[2] -> n1[100] - */ - public void testLargeNodesArray() throws Exception - { - initSNSCaseLargeArray(); - - // String n40uuid = testBase.getNode("n1[40]").getUUID(); - - Node n1__2 = testBase.getNode("n1[2]"); - Node n_21 = testBase.getNode("n_21"); - Node n_24 = testBase.getNode("n_24"); - - // === step 1 === - - // n1[2] -> n1[100] pos:120; n_21 = pos:121; ... n1[3] -> pos:2; n1[99] -> - // n1[98] pos:98; - // n1[100] -> n1[99] pos:99 - testBase.orderBefore("n1[2]", "n_21"); - - EntityCollection nodes = getEntityCollection(testBase.getNodes()); - - assertEquals("Nodes must be equals ", n1__2, nodes.getList().get(119)); // pos - // : - // 120 - assertEquals("Nodes must be equals ", n1__2, testBase.getNode("n1[100]")); - - assertEquals("Nodes must be equals ", n_21, nodes.getList().get(120)); //pos: - // 121 - assertEquals("Nodes must be equals ", n_21, testBase.getNode("n_21")); - - assertTrue("Node must exists ", testBase.hasNode("n1[2]")); - - testBase.save(); - - nodes = getEntityCollection(testBase.getNodes()); - - assertEquals("Nodes must be equals ", n1__2, nodes.getList().get(119)); // pos - // : - // 120 - assertEquals("Nodes must be equals ", n1__2, testBase.getNode("n1[100]")); - - assertEquals("Nodes must be equals ", n_21, nodes.getList().get(120)); //pos: - // 121 - assertEquals("Nodes must be equals ", n_21, testBase.getNode("n_21")); - - assertTrue("Node must exists ", testBase.hasNode("n1[2]")); - - // === step 2 === - - Node n1__100 = testBase.getNode("n1[100]"); - - // n_24 -> pos:120; n1[100] -> pos:121; - testBase.orderBefore("n_24", "n1[100]"); - - nodes = getEntityCollection(testBase.getNodes()); - - assertEquals("Nodes must be equals ", n1__100, nodes.getList().get(120)); // pos - // : - // 121 - assertEquals("Nodes must be equals ", n1__100, testBase.getNode("n1[100]")); - - assertEquals("Nodes must be equals ", n_24, nodes.getList().get(119)); //pos: - // 120 - assertEquals("Nodes must be equals ", n_24, testBase.getNode("n_24")); - - assertEquals("Nodes must be equals ", n_21, nodes.getList().get(121)); //pos: - // 122 - assertEquals("Nodes must be equals ", n_21, testBase.getNode("n_21")); - - testBase.save(); - - assertEquals("Nodes must be equals ", n1__100, nodes.getList().get(120)); // pos - // : - // 121 - assertEquals("Nodes must be equals ", n1__100, testBase.getNode("n1[100]")); - - assertEquals("Nodes must be equals ", n_24, nodes.getList().get(119)); //pos: - // 120 - assertEquals("Nodes must be equals ", n_24, testBase.getNode("n_24")); - - assertEquals("Nodes must be equals ", n_21, nodes.getList().get(121)); //pos: - // 122 - assertEquals("Nodes must be equals ", n_21, testBase.getNode("n_21")); - } - - public void testOrderTwice() throws Exception - { - - String[] order = new String[]{"n1", "n2", "n3", "n4", "n5"}; - initCustom(order); - checkOrder(testBase, order); - - testBase.orderBefore("n1", "n4"); - - order = new String[]{"n2", "n3", "n1", "n4", "n5"}; - - checkOrder(order); - - testBase.save(); - - checkOrder(order); - - checkOrderAnotherSession(order); - - testBase.orderBefore("n4", "n3"); - - order = new String[]{"n2", "n4", "n3", "n1", "n5"}; - - checkOrder(order); - - testBase.save(); - checkOrder(order); - checkOrderAnotherSession(order); - - } - public void testDeleteOrderBefore() throws Exception { Session session = repository.login(credentials, "ws"); @@ -990,48 +989,48 @@ session.save(); } - public void testDeleteOrderBefore_SNS() throws Exception - { - Session session = repository.login(credentials, "ws"); - session.getRootNode().addNode("a"); - session.save(); - session.logout(); + // public void testDeleteOrderBefore_SNS() throws Exception + // { + // Session session = repository.login(credentials, "ws"); + // session.getRootNode().addNode("a"); + // session.save(); + // session.logout(); + // + // session = repository.login(credentials, "ws"); + // Node a = session.getRootNode().getNode("a"); // We suppose it already exist + // Node n1 = a.addNode("n"); + // n1.addMixin("mix:referenceable"); + // Node n2 = a.addNode("n"); + // n2.addMixin("mix:referenceable"); + // Node n3 = a.addNode("n"); + // n3.addMixin("mix:referenceable"); + // session.save(); + // String n1id = n1.getUUID(); + // String n2id = n2.getUUID(); + // String n3id = n3.getUUID(); + // session.logout(); + // + // session = repository.login(credentials, "ws"); + // a = session.getRootNode().getNode("a"); + // a.getNode("n[2]").remove(); + // a.save(); + // session.save(); + // session.logout(); + // + // session = repository.login(credentials, "ws"); + // a = session.getRootNode().getNode("a"); + // + // try + // { + // session.getNodeByUUID(n2id); + // fail("Node with id " + n2id + " is deleted"); + // } + // catch (ItemNotFoundException e) + // { + // // ok + // } + // } - session = repository.login(credentials, "ws"); - Node a = session.getRootNode().getNode("a"); // We suppose it already exist - Node n1 = a.addNode("n"); - n1.addMixin("mix:referenceable"); - Node n2 = a.addNode("n"); - n2.addMixin("mix:referenceable"); - Node n3 = a.addNode("n"); - n3.addMixin("mix:referenceable"); - session.save(); - String n1id = n1.getUUID(); - String n2id = n2.getUUID(); - String n3id = n3.getUUID(); - session.logout(); - - session = repository.login(credentials, "ws"); - a = session.getRootNode().getNode("a"); - a.getNode("n[2]").remove(); - a.save(); - session.save(); - session.logout(); - - session = repository.login(credentials, "ws"); - a = session.getRootNode().getNode("a"); - - try - { - session.getNodeByUUID(n2id); - fail("Node with id " + n2id + " is deleted"); - } - catch (ItemNotFoundException e) - { - // ok - } - } - private EntityCollection getEntityCollection(NodeIterator nodes) { List result = new ArrayList(); Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan-config.xml =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan-config.xml (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan-config.xml 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,44 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + + Copyright (C) 2009 eXo Platform SAS. + + This 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 software 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 this software; if not, write to the Free + Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA, or see the FSF site: http://www.fsf.org. + +--> +<infinispan + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="urn:infinispan:config:4.0 http://www.infinispan.org/schemas/infinispan-config-4.0.xsd" + xmlns="urn:infinispan:config:4.0"> + + <global> + <evictionScheduledExecutor factory="org.infinispan.executors.DefaultScheduledExecutorFactory"> + <properties> + <property name="threadNamePrefix" value="EvictionThread"/> + </properties> + </evictionScheduledExecutor> + + <globalJmxStatistics jmxDomain="infinispan" enabled="true" allowDuplicateDomains="true"/> + </global> + + <default> + <locking isolationLevel="READ_COMMITTED" lockAcquisitionTimeout="20000" writeSkewCheck="false" concurrencyLevel="500"/> + <transaction transactionManagerLookupClass="org.infinispan.transaction.lookup.JBossStandaloneJTAManagerLookup" syncRollbackPhase="false" syncCommitPhase="false"/> + <jmxStatistics enabled="true"/> + <deadlockDetection enabled="true" spinDuration="100"/> + <eviction strategy="LRU" wakeUpInterval="5000" threadPolicy="DEFAULT" maxEntries="5000"/> + </default> +</infinispan> Added: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan-lock.xml =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan-lock.xml (rev 0) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan-lock.xml 2010-07-30 13:00:43 UTC (rev 2843) @@ -0,0 +1,57 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + + Copyright (C) 2009 eXo Platform SAS. + + This 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 software 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 this software; if not, write to the Free + Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + 02110-1301 USA, or see the FSF site: http://www.fsf.org. + +--> +<infinispan + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="urn:infinispan:config:4.0 http://www.infinispan.org/schemas/infinispan-config-4.0.xsd" + xmlns="urn:infinispan:config:4.0"> + + <global> + <globalJmxStatistics jmxDomain="infinispan" enabled="true" allowDuplicateDomains="true"/> + </global> + + <default> + <locking isolationLevel="READ_COMMITTED" lockAcquisitionTimeout="20000" writeSkewCheck="false" concurrencyLevel="500"/> + <transaction transactionManagerLookupClass="org.infinispan.transaction.lookup.JBossStandaloneJTAManagerLookup" syncRollbackPhase="false" syncCommitPhase="false"/> + <jmxStatistics enabled="true"/> + <deadlockDetection enabled="true" spinDuration="100"/> + + <loaders passivation="false" shared="true" preload="true"> + <loader class="org.infinispan.loaders.jdbc.stringbased.JdbcStringBasedCacheStore" fetchPersistentState="false" ignoreModifications="false" purgeOnStartup="false"> + <properties> + <property name="stringsTableNamePrefix" value="${infinispan-cl-cache.jdbc.table.name}"/> + <property name="idColumnName" value="${infinispan-cl-cache.jdbc.id.column}"/> + <property name="dataColumnName" value="${infinispan-cl-cache.jdbc.data.column}"/> + <property name="timestampColumnName" value="${infinispan-cl-cache.jdbc.timestamp.column}"/> + <property name="idColumnType" value="${infinispan-cl-cache.jdbc.id.type}"/> + <property name="dataColumnType" value="${infinispan-cl-cache.jdbc.data.type}"/> + <property name="timestampColumnType" value="${infinispan-cl-cache.jdbc.timestamp.type}"/> + <property name="dropTableOnExit" value="${infinispan-cl-cache.jdbc.table.drop}"/> + <property name="createTableOnStart" value="${infinispan-cl-cache.jdbc.table.create}"/> + <property name="connectionFactoryClass" value="${infinispan-cl-cache.jdbc.connectionFactory}"/> + <property name="datasourceJndiLocation" value="${infinispan-cl-cache.jdbc.datasource}"/> + </properties> + <async enabled="false"/> + </loader> + </loaders> + </default> + +</infinispan> Deleted: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan.xml =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan.xml 2010-07-30 11:40:38 UTC (rev 2842) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-infinispan.xml 2010-07-30 13:00:43 UTC (rev 2843) @@ -1,64 +0,0 @@ -<?xml version="1.0" encoding="UTF-8"?> -<!-- - - Copyright (C) 2009 eXo Platform SAS. - - This 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 software 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 this software; if not, write to the Free - Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA - 02110-1301 USA, or see the FSF site: http://www.fsf.org. - ---> -<infinispan - xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" - xsi:schemaLocation="urn:infinispan:config:4.0 http://www.infinispan.org/schemas/infinispan-config-4.0.xsd" - xmlns="urn:infinispan:config:4.0"> - - <global> - <evictionScheduledExecutor factory="org.infinispan.executors.DefaultScheduledExecutorFactory"> - <properties> - <property name="threadNamePrefix" value="EvictionThread"/> - </properties> - </evictionScheduledExecutor> - - <globalJmxStatistics jmxDomain="infinispan" enabled="true" allowDuplicateDomains="true"/> - </global> - - <default> - <locking isolationLevel="READ_COMMITTED" lockAcquisitionTimeout="20000" writeSkewCheck="false" concurrencyLevel="500"/> - <transaction transactionManagerLookupClass="org.infinispan.transaction.lookup.JBossStandaloneJTAManagerLookup" syncRollbackPhase="false" syncCommitPhase="false"/> - <jmxStatistics enabled="true"/> - <deadlockDetection enabled="true" spinDuration="100"/> - </default> - - <namedCache name="lockCache"> - <loaders passivation="false" shared="true" preload="true"> - <loader class="org.infinispan.loaders.jdbc.stringbased.JdbcStringBasedCacheStore" fetchPersistentState="false" ignoreModifications="false" purgeOnStartup="false"> - <properties> - <property name="stringsTableNamePrefix" value="${infinispan-cl-cache.jdbc.table.name}"/> - <property name="idColumnName" value="${infinispan-cl-cache.jdbc.id.column}"/> - <property name="dataColumnName" value="${infinispan-cl-cache.jdbc.data.column}"/> - <property name="timestampColumnName" value="${infinispan-cl-cache.jdbc.timestamp.column}"/> - <property name="idColumnType" value="${infinispan-cl-cache.jdbc.id.type}"/> - <property name="dataColumnType" value="${infinispan-cl-cache.jdbc.data.type}"/> - <property name="timestampColumnType" value="${infinispan-cl-cache.jdbc.timestamp.type}"/> - <property name="dropTableOnExit" value="${infinispan-cl-cache.jdbc.table.drop}"/> - <property name="createTableOnStart" value="${infinispan-cl-cache.jdbc.table.create}"/> - <property name="connectionFactoryClass" value="${infinispan-cl-cache.jdbc.connectionFactory}"/> - <property name="datasourceJndiLocation" value="${infinispan-cl-cache.jdbc.datasource}"/> - </properties> - <async enabled="false"/> - </loader> - </loaders> - </namedCache> -</infinispan> Modified: jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-jcr-config.xml =================================================================== --- jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-jcr-config.xml 2010-07-30 11:40:38 UTC (rev 2842) +++ jcr/branches/1.14-ISPN/exo.jcr.component.core/src/test/resources/conf/standalone/test-jcr-config.xml 2010-07-30 13:00:43 UTC (rev 2843) @@ -65,9 +65,9 @@ <property name="restore-path" value="./src/test/resources/import-export/restore_db1_ws1.xml" /> </properties> </initializer --> - <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.jbosscache.JBossCacheWorkspaceStorageCache"> + <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan.ISPNCacheWorkspaceStorageCache"> <properties> - <property name="jbosscache-configuration" value="conf/standalone/test-jbosscache-config.xml" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> </properties> </cache> <query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex"> @@ -81,8 +81,7 @@ <lock-manager class="org.exoplatform.services.jcr.impl.core.lock.infinispan.ISPNCacheableLockManagerImpl"> <properties> <property name="time-out" value="15m" /> - <property name="infinispan-configuration" value="conf/standalone/test-infinispan.xml" /> - <property name="infinispan-cache-name" value="lockCache" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> <property name="infinispan-cl-cache.jdbc.table.name" value="jcrlocks_db1_ws" /> <property name="infinispan-cl-cache.jdbc.table.create" value="true" /> <property name="infinispan-cl-cache.jdbc.table.drop" value="false" /> @@ -116,9 +115,9 @@ </value-storage> </value-storages> </container> - <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.jbosscache.JBossCacheWorkspaceStorageCache"> + <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan.ISPNCacheWorkspaceStorageCache"> <properties> - <property name="jbosscache-configuration" value="conf/standalone/test-jbosscache-config.xml" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> </properties> </cache> <query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex"> @@ -135,8 +134,7 @@ <lock-manager class="org.exoplatform.services.jcr.impl.core.lock.infinispan.ISPNCacheableLockManagerImpl"> <properties> <property name="time-out" value="15m" /> - <property name="infinispan-configuration" value="conf/standalone/test-infinispan.xml" /> - <property name="infinispan-cache-name" value="lockCache" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> <property name="infinispan-cl-cache.jdbc.table.name" value="jcrlocks_db1_ws1" /> <property name="infinispan-cl-cache.jdbc.table.create" value="true" /> <property name="infinispan-cl-cache.jdbc.table.drop" value="false" /> @@ -170,9 +168,9 @@ </value-storage> </value-storages> </container> - <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.jbosscache.JBossCacheWorkspaceStorageCache"> + <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan.ISPNCacheWorkspaceStorageCache"> <properties> - <property name="jbosscache-configuration" value="conf/standalone/test-jbosscache-config.xml" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> </properties> </cache> <query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex"> @@ -189,8 +187,7 @@ <lock-manager class="org.exoplatform.services.jcr.impl.core.lock.infinispan.ISPNCacheableLockManagerImpl"> <properties> <property name="time-out" value="15m" /> - <property name="infinispan-configuration" value="conf/standalone/test-infinispan.xml" /> - <property name="infinispan-cache-name" value="lockCache" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> <property name="infinispan-cl-cache.jdbc.table.name" value="jcrlocks_db1_ws2" /> <property name="infinispan-cl-cache.jdbc.table.create" value="true" /> <property name="infinispan-cl-cache.jdbc.table.drop" value="false" /> @@ -251,9 +248,9 @@ <property name="root-nodetype" value="nt:unstructured" /> </properties> </initializer> - <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.jbosscache.JBossCacheWorkspaceStorageCache"> + <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan.ISPNCacheWorkspaceStorageCache"> <properties> - <property name="jbosscache-configuration" value="conf/standalone/test-jbosscache-config.xml" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> </properties> </cache> <query-handler @@ -272,8 +269,7 @@ <lock-manager class="org.exoplatform.services.jcr.impl.core.lock.infinispan.ISPNCacheableLockManagerImpl"> <properties> <property name="time-out" value="15m" /> - <property name="infinispan-configuration" value="conf/standalone/test-infinispan.xml" /> - <property name="infinispan-cache-name" value="lockCache" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> <property name="infinispan-cl-cache.jdbc.table.name" value="jcrlocks_db1_ws3" /> <property name="infinispan-cl-cache.jdbc.table.create" value="true" /> <property name="infinispan-cl-cache.jdbc.table.drop" value="false" /> @@ -323,9 +319,9 @@ <property name="root-permissions" value="any read;*:/platform/administrators read;*:/platform/administrators add_node;*:/platform/administrators set_property;*:/platform/administrators remove" /> </properties> </initializer> - <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.jbosscache.JBossCacheWorkspaceStorageCache"> + <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan.ISPNCacheWorkspaceStorageCache"> <properties> - <property name="jbosscache-configuration" value="conf/standalone/test-jbosscache-config.xml" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> </properties> </cache> <query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex"> @@ -343,8 +339,7 @@ <lock-manager class="org.exoplatform.services.jcr.impl.core.lock.infinispan.ISPNCacheableLockManagerImpl"> <properties> <property name="time-out" value="15m" /> - <property name="infinispan-configuration" value="conf/standalone/test-infinispan.xml" /> - <property name="infinispan-cache-name" value="lockCache" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> <property name="infinispan-cl-cache.jdbc.table.name" value="jcrlocks_db1tck_ws" /> <property name="infinispan-cl-cache.jdbc.table.create" value="true" /> <property name="infinispan-cl-cache.jdbc.table.drop" value="false" /> @@ -384,9 +379,9 @@ <property name="root-permissions" value="any read;*:/platform/administrators read;*:/platform/administrators add_node;*:/platform/administrators set_property;*:/platform/administrators remove" /> </properties> </initializer> - <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.jbosscache.JBossCacheWorkspaceStorageCache"> + <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan.ISPNCacheWorkspaceStorageCache"> <properties> - <property name="jbosscache-configuration" value="conf/standalone/test-jbosscache-config.xml" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> </properties> </cache> <query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex"> @@ -403,8 +398,7 @@ <lock-manager class="org.exoplatform.services.jcr.impl.core.lock.infinispan.ISPNCacheableLockManagerImpl"> <properties> <property name="time-out" value="15m" /> - <property name="infinispan-configuration" value="conf/standalone/test-infinispan.xml" /> - <property name="infinispan-cache-name" value="lockCache" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> <property name="infinispan-cl-cache.jdbc.table.name" value="jcrlocks_db1tck_ws1" /> <property name="infinispan-cl-cache.jdbc.table.create" value="true" /> <property name="infinispan-cl-cache.jdbc.table.drop" value="false" /> @@ -444,9 +438,9 @@ <property name="root-permissions" value="any read;*:/platform/administrators read;*:/platform/administrators add_node;*:/platform/administrators set_property;*:/platform/administrators remove" /> </properties> </initializer> - <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.jbosscache.JBossCacheWorkspaceStorageCache"> + <cache enabled="true" class="org.exoplatform.services.jcr.impl.dataflow.persistent.infinispan.ISPNCacheWorkspaceStorageCache"> <properties> - <property name="jbosscache-configuration" value="conf/standalone/test-jbosscache-config.xml" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> </properties> </cache> <query-handler class="org.exoplatform.services.jcr.impl.core.query.lucene.SearchIndex"> @@ -466,8 +460,7 @@ <lock-manager class="org.exoplatform.services.jcr.impl.core.lock.infinispan.ISPNCacheableLockManagerImpl"> <properties> <property name="time-out" value="15m" /> - <property name="infinispan-configuration" value="conf/standalone/test-infinispan.xml" /> - <property name="infinispan-cache-name" value="lockCache" /> + <property name="infinispan-configuration" value="conf/standalone/test-infinispan-config.xml" /> <property name="infinispan-cl-cache.jdbc.table.name" value="jcrlocks_db1tck_ws2" /> <property name="infinispan-cl-cache.jdbc.table.create" value="true" /> <property name="infinispan-cl-cache.jdbc.table.drop" value="false" />