inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-08-07 17:49:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merged HEAD-BUG-FIX (4.3/Cloud) to HEAD (4.3/Cloud)

Browse Source 
59034: Merged V4.2-BUG-FIX (4.2.1) to HEAD-BUG-FIX (Cloud/4.3)
      59000: Merged V4.1-BUG-FIX (4.1.8) to V4.2-BUG-FIX (4.2.1)
         - Missing file in last commit
         58913: Fix MT ContentStore so that it cannot return a null store
          - It was dependent, for some reason, on a cluster-aware cache that would be prone to nulling
            but the code just assumed that if it tried to set the value a few times it would stick.
          - Fixed transaction demarcation so that a transaction is always present when using the store.
            This is not ideal but it is inherently a repo-aware component and therefore needs it
          - MNT-9806: Prevent post-transaction handlers from rendering threads unusable
          - MNT-10096: MT: AbstractTenantRoutingContentStore can return null list of stores
         Merged from DEV/DEREK/MNT-9806 r58833


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@62078 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Alan Davis
2014-02-12 00:46:37 +00:00
parent 75730e988f
commit dd4f7bfaf5
1 changed files with 93 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

180
source/java/org/alfresco/repo/tenant/AbstractTenantRoutingContentStore.java
View File

@@ -19,12 +19,14 @@
package org.alfresco.repo.tenant;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
import org.alfresco.repo.cache.SimpleCache;
import org.alfresco.repo.content.AbstractRoutingContentStore;
import org.alfresco.repo.content.ContentContext;
import org.alfresco.repo.content.ContentStore;
@@ -34,6 +36,8 @@ import org.alfresco.repo.security.authentication.AuthenticationUtil;
import org.alfresco.repo.tenant.TenantUtil.TenantRunAsWork;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback;
import org.alfresco.service.transaction.TransactionService;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
@@ -51,15 +55,22 @@ public abstract class AbstractTenantRoutingContentStore extends AbstractRoutingC
private TenantAdminDAO tenantAdminDAO;
protected TenantService tenantService;
private ApplicationContext applicationContext;
private TransactionService transactionService;
private final ReentrantReadWriteLock tenantContentStoreLock = new ReentrantReadWriteLock();
private final WriteLock tenantContentStoreWriteLock = tenantContentStoreLock.writeLock();
private final ReadLock tenantContentStoreReadLock = tenantContentStoreLock.readLock();
// note: cache is tenant-aware (if using TransctionalCache impl)
private SimpleCache<String, ContentStore> singletonCache; // eg. for contentStore
private final String KEY_CONTENT_STORE = "key.tenant.routing.content.store";
// note: cache is tenant-aware (if using EhCacheAdapter shared cache)
private final Map<String, ContentStore> cache;
/**
* Default constructor
*/
protected AbstractTenantRoutingContentStore()
{
this.cache = new HashMap<String, ContentStore>(1024);
}
public void setRootLocation(String defaultRootDirectory)
{
@@ -76,20 +87,16 @@ public abstract class AbstractTenantRoutingContentStore extends AbstractRoutingC
this.tenantAdminDAO = tenantAdminDAO;
}
public void setSingletonCache(SimpleCache<String, ContentStore> singletonCache)
{
this.singletonCache = singletonCache;
}
/* (non-Javadoc)
* @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.
* ApplicationContext)
*/
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
{
this.applicationContext = applicationContext;
}
public void setTransactionService(TransactionService transactionService)
{
this.transactionService = transactionService;
}
@Override
public String getRootLocation()
{
@@ -99,111 +106,103 @@ public abstract class AbstractTenantRoutingContentStore extends AbstractRoutingC
@Override
protected ContentStore selectWriteStore(ContentContext ctx)
{
return getTenantContentStore();
RetryingTransactionCallback<ContentStore> callback = new RetryingTransactionCallback<ContentStore>()
{
@Override
public ContentStore execute() throws Throwable
{
return getTenantContentStore();
}
};
return transactionService.getRetryingTransactionHelper().doInTransaction(callback, true, false);
}
@Override
public List<ContentStore> getAllStores()
{
final List<ContentStore> allEnabledStores = new ArrayList<ContentStore>();
if (tenantService.isEnabled())
RetryingTransactionCallback<List<ContentStore>> callback = new RetryingTransactionCallback<List<ContentStore>>()
{
String currentUser = AuthenticationUtil.getFullyAuthenticatedUser();
if ((currentUser == null) || (tenantService.getBaseNameUser(currentUser).equals(AuthenticationUtil.getSystemUserName())))
@Override
public List<ContentStore> execute() throws Throwable
{
// return enabled stores across all tenants, if running as system/null user, for example, ContentStoreCleaner scheduled job
List<TenantEntity> tenants = tenantAdminDAO.listTenants(false);
for (TenantEntity tenant : tenants)
{
if (tenant.getEnabled())
{
String tenantDomain = tenant.getTenantDomain();
TenantUtil.runAsSystemTenant(new TenantRunAsWork<Void>()
{
public Void doWork() throws Exception
{
allEnabledStores.add(getTenantContentStore()); // note: cache should only contain enabled stores
return null;
}
}, tenantDomain);
}
}
if (logger.isDebugEnabled())
{
logger.debug("getAllStores called without tenant ctx ("+tenants.size()+" tenants)");
}
// drop through to ensure default content store has been init'ed
return getAllStoresImpl();
}
};
return transactionService.getRetryingTransactionHelper().doInTransaction(callback, true, false);
}
/**
* Work method to build a list of stores and <b>must always be called from withing an active transaction</b>.
*/
private List<ContentStore> getAllStoresImpl()
{
ContentStore cs = getTenantContentStore();
// Bypass everything if MT is disabled
if (!tenantService.isEnabled())
{
return Collections.singletonList(cs);
}
allEnabledStores.add(getTenantContentStore());
final List<ContentStore> allEnabledStores = new ArrayList<ContentStore>();
allEnabledStores.add(cs);
String currentUser = AuthenticationUtil.getFullyAuthenticatedUser();
if ((currentUser == null) || (tenantService.getBaseNameUser(currentUser).equals(AuthenticationUtil.getSystemUserName())))
{
// return enabled stores across all tenants, if running as system/null user, for example, ContentStoreCleaner scheduled job
List<TenantEntity> tenants = tenantAdminDAO.listTenants(false);
for (TenantEntity tenant : tenants)
{
if (tenant.getEnabled())
{
String tenantDomain = tenant.getTenantDomain();
TenantUtil.runAsSystemTenant(new TenantRunAsWork<Void>()
{
public Void doWork() throws Exception
{
allEnabledStores.add(getTenantContentStore()); // note: cache should only contain enabled stores
return null;
}
}, tenantDomain);
}
}
}
return allEnabledStores;
}
private ContentStore getTenantContentStore()
{
String tenantDomain = tenantService.getCurrentUserDomain();
ContentStore cs = null;
tenantContentStoreReadLock.lock();
try
{
cs = getTenantContentStoreImpl();
cs = cache.get(tenantDomain);
if (cs != null)
{
return cs;
}
}
finally
{
tenantContentStoreReadLock.unlock();
}
if (cs == null)
{
synchronized (this)
{
cs = getTenantContentStoreImpl();
if (cs == null)
{
init();
cs = getTenantContentStoreImpl();
}
}
}
return cs;
}
private ContentStore getTenantContentStoreImpl()
{
return (ContentStore)singletonCache.get(KEY_CONTENT_STORE);
}
private void putTenantContentStoreImpl(ContentStore contentStore)
{
singletonCache.put(KEY_CONTENT_STORE, contentStore);
}
private void removeTenantContentStoreImpl()
{
singletonCache.remove(KEY_CONTENT_STORE);
}
public void init()
{
// It was not found, so go and initialize it
tenantContentStoreWriteLock.lock();
try
{
String rootDir = getRootLocation();
Tenant tenant = tenantService.getTenant(tenantService.getCurrentUserDomain());
if (tenant != null)
Tenant tenant = tenantService.getTenant(tenantDomain);
if (tenant != null && tenant.getRootContentStoreDir() != null)
{
if (tenant.getRootContentStoreDir() != null)
{
rootDir = tenant.getRootContentStoreDir();
}
rootDir = tenant.getRootContentStoreDir();
}
putTenantContentStoreImpl(initContentStore(this.applicationContext, rootDir));
cs = initContentStore(applicationContext, rootDir);
cache.put(tenantDomain, cs);
return cs;
}
finally
{
@@ -211,12 +210,19 @@ public abstract class AbstractTenantRoutingContentStore extends AbstractRoutingC
}
}
@Override
public void init()
{
getTenantContentStore();
}
public void destroy()
{
String tenantDomain = tenantService.getCurrentUserDomain();
tenantContentStoreWriteLock.lock();
try
{
removeTenantContentStoreImpl();
cache.remove(tenantDomain);
}
finally
{