alfresco-community-repo/source/java/org/alfresco/repo/tenant/MultiTAdminServiceImpl.java
Dave Ward d437d5105d Merged V4.0-BUG-FIX to HEAD
36311: BDE-69: filter long tests if minimal.testing property is defined
   36314: Merged V4.0 to V4.0-BUG-FIX (RECORD ONLY)
      36247: ALF-11027: temporarily remove import of maven.xml, since it makes ant calls fail from enterpriseprojects
   36331: ALF-12447: Further changes required to fix lower case meta-inf folder name
   36333: Revert ALF-12447.
   36334: ALF-14115: Merged V3.4-BUG-FIX to V4.0-BUG-FIX
      36318: ALF-12447: Fix case on META-INF folder for SDK
      36332: ALF-12447: Further changes required to fix lower case meta-inf folder name
   36337: ALF-14115: Merged V3.4-BUG-FIX to V4.0-BUG-FIX
      36332: ALF-12447: Yet more meta-inf case changes needed.
   36342: ALF-14120: fix only completed tasks returned
   36343: ALF-13898: starting workflow from IMAP now using workflowDefs with engine name included, fallback to appending $jbpm when not present, to preserve backwards compatibility.
   36345: Fix for ALF-12730 - Email Space Users fails if template is used
   36346: Fix for ALF-9466 - We can search contents sorted by categories in Advanced search in Share, but saved search will not be shown in UI.
   36364: Switch version to 4.0.3
   36375: Merged BRANCHES/DEV/CLOUDSYNCLOCAL2 to BRANCHES/DEV/V4.0-BUG-FIX:
      36366: Tweak to implementation to ensure that on-authentication-failed, the status is updated within a r/w transaction.
      36374: Provide more specific exceptions from the Remote Connector Service for client and server errors
   36376: Fix ALF-14121 - Alfresco fails to start if using "replicating-content-services-context.xml"
   36393: Final part of ALF-13723 SOLR does not include the same query unit tests as lucene
   - CMIS typed query and ordering tests
   36432: ALF-14133: Merged V3.4-BUG-FIX (3.4.10) to V4.0-BUG-FIX (4.0.3)
      << 4.0.x specific change: Changed transformer.complex.OOXML.Image into transformer.complex.Any.Image >>
      << allowing any transformer to be selected for the conversion to JPEG >>
      36427: ALF-14131 Complex transformers fail if a lower level transformer fails even though there is another transformer that could do the transformation
         - Added a base spring bean for all complex transformers
      36362: ALF-14131 Complex transformers fail if a lower level transformer fails even though there is another transformer that could do the transformation
   36434: Test fix for ALF-13723 SOLR does not include the same query unit tests as lucene
   - CMIS test data change broke AFTS ID ordering
   36503: Removed thousands of compiler warnings (CMIS query test code)
   36518: Fix for ALF-13778 - Links on Share Repository search page show incorrect link name; do not work when root-node is defined.
   Fix now means that Share search correctly handles overridden Repository root node setting. Original work by Vasily Olhin.
   36520: BDE-69: filter all repo tests if minimal.testing property is defined
   36534: ALF-14116: Latest Surf libs (r1075) - ensure that i18n extensions can process browser sent short locales
   36563: Merged V3.4-BUG-FIX to V4.0-BUG-FIX
      36336: ALF-12447: Yet more meta-inf case changes needed.
      36347: Fix for ALF-13920 - Error occurred when try to edit/delete category
      36352: Fix for ALF-13123 - Invalid JSON format from Get Node Tags Webscript - strings not double-quoted. Also fixed POST webscript with same issue.
      36399: ALL LANG: translation updates based on EN r36392
      36421: Fix for Mac Lion versioning issue. ALF-12792 (Part 1 of 2)
      Enable the InfoPassthru and Level2Oplocks server capability flags, InfoPassthru is the flag that fixes the Mac Lion versioning error.
      Added support for filesystems that do not implement the NTFS streams interface in the CIFS transact rename processing, for the Alfresco repo filesystem.
      36422: Fix for Mac Lion versioning issue. ALF-12792 (Part 2 of 2)
      Enable the InfoPassthru and Level2Oplocks server capability flags, InfoPassthru is the flag that fixes the Mac Lion versioning error.
      36423: Add support for file size tracking in the file state. ALF-13616 (Part 1 of 2)
      36424: Fix for Mac MS Word file save issue. ALF-13616 (Part 2 of 2)
      Added live file size tracking to file writing/folder searches so the correct file size is returned before the file is closed.
      36444: Merged DEV to V3.4-BUG-FIX
         36419: ALF-12666 Search against simple-search-additional-attributes doesn't work properly
            SearchContext.buildQuery(int) method was changed.
      36446: Fix for ALF-13404 - Performance: 'Content I'm Editing' dashlet is slow to render when there is lots of data/sites
       - Effectively removed all PATH based queries using the pattern /companyhome/sites/*/container//* as they are a non-optimized case
       - Replaced the "all sites" doclist query using the above pattern with /companyhome/sites//* plus post query resultset processing based on documentLibrary container matching regex
       - Optimized favorite document query to remove need for a PATH
       - Optimized Content I'm Editing discussion PATH query to use /*/* instead of /*//*
       - Fixed issue where Content I'm Editing discussion results would not always show the root topics that a user has edited
       - Added some addition doclist.get.js query scriptlogger debugging output
      36449: ALF-13404 - Fix for issue where favoriates for all sites would be shown in each site document library in the My Favorites filter.
      36475: ALF-14131 Complex transformers fail if a lower level transformer fails even though there is another transformer that could do the transformation
         - Change base spring bean on example config file
      36480: 36453: ALF-3881 : ldap sync deletion behaviour not flexible enough
         - synchronization.allowDeletions parameter introduced
         - default value is true (existing behaviour)
         - when false, no missing users or groups are deleted from the repository
         - instead they are cleared of their zones and missing groups are cleared of all their members
         - colliding users and groups from different zones are also 'moved' rather than recreated
         - unit test added
      36491: Added CIFS transact2 NT passthru levels for set end of file/set allocation size. ALF-13616.
      Also updated FileInfoLevel with the latest list of NT passthru information levels.
      36497: Fixed ALF-14163: JavaScript Behaviour broken: Node properties cannot be cast to java.io.Serializable
       - Fallout from ALF-12855
       - Made class Serializable (like HashMap would have been)
       - Fixed line endings, too
      36531: ALF-13769: Merged BELARUS/V3.4-BUG-FIX-2012_04_05 to V3.4-BUG-FIX (3.4.10)
         35150: ALF-2645 : 3.2+ ldap sync debug information is too scarce 
            - Improved LDAP logging.
      36532: ALF-13769: BRANCHES/DEV/BELARUS/V3.4-BUG-FIX-2012_01_26 to V3.4-BUG-FIX (3.4.10)
         36461: ALF-237: WCM: File conflicts cause file order not to be consistent
            - It is reasonable set values for checkboxes using the indexes from the list, which are not changed. So when we submit the window, the getSelectedNodes method is invoked and 
              it takes selected nodes by checkbox values from "paths" list. 
      36535: Merged DEV to V3.4-BUG-FIX
         36479: ALF-8918 : Cannot "edit offline" a web quick start publication
            A check in TaggableAspect.onUpdatePropertiesOnCommit() was extended to skip the update, if no tags were changed.
      36555: Merged V3.4 to V3.4-BUG-FIX
         36294: ALF-14039: Merged HEAD to V3.4
            31732: ALF-10934: Prevent potential start/stop ping-pong of subsystems across a cluster
               - When a cluster boots up or receives a reinit message it shouldn't be sending out any start messages
   36566: Merged V3.4-BUG-FIX to V4.0-BUG-FIX (RECORD ONLY)
      36172: Merged BRANCHES/DEV/V4.0-BUG-FIX to BRANCHES/DEV/V3.4-BUG-FIX:
         36169: ALF-8755: After renaming content / space by Contributor via WebDAV new items are created
   36572: Merged V4.0 to V4.0-BUG-FIX
      36388: ALF-14025: Updated Surf libs (1071). Fixes to checksum-disabled dependency handling
      36392: ALF-14129 Failed to do upgrade from 3.4.8 to 4.0.2
         << Committed change for Frederik Heremans >>
         - Moved actual activiti-tables creation to before the upgrade
      36409: Fix for ALF-14124 Solr is not working - Errors occur during the startup
      36466: Fix for ALF-12770 - Infinite loop popup alert in TinyMCE after XSS injection in Alfresco Explorer online edit.
      36501: Merged DEV to V4.0
         36496: ALF-14063 : CLONE - Internet Explorer hangs when using the object picker with a larger number of documents
            YUI 2.9.0 library was modified to use chunked unloading of listeners via a series of setTimeout() functions in event.js for IE 6,7,8.
      36502: ALF-14105: Share Advanced search issue with the form values
      - Fix by David We
      36538: ALF-13986: Updated web.xml and index.jsp redirect to ensure that SSO works with proper surf site-configuration customization
      36539: Fix for ALF-14167 Filtering by Tags/Categories doen't findes any content in Repository/DocumentLibrary
      - fix default namespace back to "" -> "" and fix the specific SOLR tests that require otherwise.
      36541: ALF-14082: Input stream leaks in thumbnail rendering webscripts
      36560: Correctly size content length header after HTML stripping process (ALF-9365)
   36574: Merged V4.0 to V4.0-BUG-FIX (RECORD ONLY)
      36316: Merged V4.0-BUG-FIX to V4.0 (4.0.2)
      36391: Merged V4.0-BUG-FIX to V4.0
         36376: Fix ALF-14121 - Alfresco fails to start if using "replicating-content-services-context.xml"


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@36576 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
2012-05-18 17:00:53 +00:00

1299 lines
51 KiB
Java

/*
* Copyright (C) 2005-2012 Alfresco Software Limited.
*
* This file is part of Alfresco
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/
package org.alfresco.repo.tenant;
import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.regex.Pattern;
import javax.transaction.UserTransaction;
import net.sf.acegisecurity.providers.encoding.PasswordEncoder;
import org.alfresco.error.AlfrescoRuntimeException;
import org.alfresco.repo.admin.RepoModelDefinition;
import org.alfresco.repo.content.ContentStore;
import org.alfresco.repo.dictionary.DictionaryComponent;
import org.alfresco.repo.domain.tenant.TenantAdminDAO;
import org.alfresco.repo.domain.tenant.TenantEntity;
import org.alfresco.repo.domain.tenant.TenantUpdateEntity;
import org.alfresco.repo.importer.ImporterBootstrap;
import org.alfresco.repo.node.db.DbNodeServiceImpl;
import org.alfresco.repo.security.authentication.AuthenticationContext;
import org.alfresco.repo.security.authentication.AuthenticationException;
import org.alfresco.repo.security.authentication.AuthenticationUtil;
import org.alfresco.repo.security.authentication.AuthenticationUtil.RunAsWork;
import org.alfresco.repo.thumbnail.ThumbnailRegistry;
import org.alfresco.repo.usage.UserUsageTrackingComponent;
import org.alfresco.repo.workflow.WorkflowDeployer;
import org.alfresco.service.cmr.admin.RepoAdminService;
import org.alfresco.service.cmr.module.ModuleService;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.cmr.repository.StoreRef;
import org.alfresco.service.cmr.view.RepositoryExporterService;
import org.alfresco.service.cmr.workflow.WorkflowDefinition;
import org.alfresco.service.cmr.workflow.WorkflowService;
import org.alfresco.service.transaction.TransactionService;
import org.alfresco.util.PropertyCheck;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.extensions.surf.util.I18NUtil;
import org.springframework.extensions.surf.util.ParameterCheck;
/**
* MT Admin Service Implementation.
*
*/
public class MultiTAdminServiceImpl implements TenantAdminService, ApplicationContextAware, InitializingBean
{
// Logger
private static Log logger = LogFactory.getLog(MultiTAdminServiceImpl.class);
// Keep hold of the app context
private ApplicationContext ctx;
// Dependencies
private NodeService nodeService;
private RepoAdminService repoAdminService;
private AuthenticationContext authenticationContext;
private MultiTServiceImpl tenantService;
protected TransactionService transactionService;
protected DictionaryComponent dictionaryComponent;
protected TenantAdminDAO tenantAdminDAO;
protected PasswordEncoder passwordEncoder;
protected ContentStore tenantFileContentStore;
private ThumbnailRegistry thumbnailRegistry;
private WorkflowService workflowService;
private RepositoryExporterService repositoryExporterService;
private ModuleService moduleService;
private List<WorkflowDeployer> workflowDeployers = new ArrayList<WorkflowDeployer>();
private String baseAdminUsername = null;
/*
* Tenant domain/ids are unique strings that are case-insensitive. Tenant ids must be valid filenames.
* They may also map onto domains and hence should allow valid FQDN.
*
* The following PCRE-style
* regex defines a valid label within a FQDN:
*
* ^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9]$
*
* Less formally:
*
* o Case insensitive
* o First/last character: alphanumeric
* o Interior characters: alphanumeric plus hyphen
* o Minimum length: 2 characters
* o Maximum length: 63 characters
*
* The FQDN (fully qualified domain name) has the following constraints:
*
* o Maximum 255 characters (***)
* o Must contain at least one alpha
*
* Note: (***) Due to various internal restrictions (such as store identifier) we restrict tenant ids to 75 characters.
*/
protected final static String REGEX_VALID_DNS_LABEL = "^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9]$";
protected final static String REGEX_CONTAINS_ALPHA = "^(.*)[a-zA-Z](.*)$";
protected final static int MAX_LEN = 75;
public void setNodeService(DbNodeServiceImpl dbNodeService)
{
this.nodeService = dbNodeService;
}
public void setDictionaryComponent(DictionaryComponent dictionaryComponent)
{
this.dictionaryComponent = dictionaryComponent;
}
public void setRepoAdminService(RepoAdminService repoAdminService)
{
this.repoAdminService = repoAdminService;
}
public void setAuthenticationContext(AuthenticationContext authenticationContext)
{
this.authenticationContext = authenticationContext;
}
public void setTransactionService(TransactionService transactionService)
{
this.transactionService = transactionService;
}
public void setTenantService(MultiTServiceImpl tenantService)
{
this.tenantService = tenantService;
}
public void setTenantAdminDAO(TenantAdminDAO tenantAdminDAO)
{
this.tenantAdminDAO = tenantAdminDAO;
}
public void setPasswordEncoder(PasswordEncoder passwordEncoder)
{
this.passwordEncoder = passwordEncoder;
}
public void setTenantFileContentStore(ContentStore tenantFileContentStore)
{
this.tenantFileContentStore = tenantFileContentStore;
}
public void setWorkflowService(WorkflowService workflowService)
{
this.workflowService = workflowService;
}
public void setRepositoryExporterService(RepositoryExporterService repositoryExporterService)
{
this.repositoryExporterService = repositoryExporterService;
}
/**
* @deprecated see setWorkflowDeployers
*/
public void setWorkflowDeployer(WorkflowDeployer workflowDeployer)
{
// NOOP
logger.warn(WARN_MSG);
}
public void setModuleService(ModuleService moduleService)
{
this.moduleService = moduleService;
}
public void setThumbnailRegistry(ThumbnailRegistry thumbnailRegistry)
{
this.thumbnailRegistry = thumbnailRegistry;
}
public void setBaseAdminUsername(String baseAdminUsername)
{
this.baseAdminUsername = baseAdminUsername;
}
public static final String PROTOCOL_STORE_USER = "user";
public static final String PROTOCOL_STORE_WORKSPACE = "workspace";
public static final String PROTOCOL_STORE_SYSTEM = "system";
public static final String PROTOCOL_STORE_ARCHIVE = "archive";
public static final String STORE_BASE_ID_USER = "alfrescoUserStore";
public static final String STORE_BASE_ID_SYSTEM = "system";
public static final String STORE_BASE_ID_VERSION1 = "lightWeightVersionStore"; // deprecated
public static final String STORE_BASE_ID_VERSION2 = "version2Store";
public static final String STORE_BASE_ID_SPACES = "SpacesStore";
public static final String TENANTS_ATTRIBUTE_PATH = "alfresco-tenants";
public static final String TENANT_ATTRIBUTE_ENABLED = "enabled";
public static final String TENANT_ATTRIBUTE_ROOT_CONTENT_STORE_DIR = "rootContentStoreDir";
private List<TenantDeployer> tenantDeployers = new ArrayList<TenantDeployer>();
private static final String WARN_MSG = "system.mt.warn.upgrade_mt_admin_context";
public void afterPropertiesSet() throws Exception
{
// for upgrade/backwards compatibility with 3.0.x (mt-admin-context.xml)
if (baseAdminUsername == null)
{
logger.warn(I18NUtil.getMessage(WARN_MSG));
}
PropertyCheck.mandatory(this, "NodeService", nodeService);
PropertyCheck.mandatory(this, "DictionaryComponent", dictionaryComponent);
PropertyCheck.mandatory(this, "RepoAdminService", repoAdminService);
PropertyCheck.mandatory(this, "TransactionService", transactionService);
PropertyCheck.mandatory(this, "TenantService", tenantService);
PropertyCheck.mandatory(this, "TenantAdminDAO", tenantAdminDAO);
PropertyCheck.mandatory(this, "PasswordEncoder", passwordEncoder);
PropertyCheck.mandatory(this, "TenantFileContentStore", tenantFileContentStore);
PropertyCheck.mandatory(this, "WorkflowService", workflowService);
PropertyCheck.mandatory(this, "RepositoryExporterService", repositoryExporterService);
PropertyCheck.mandatory(this, "moduleService", moduleService);
}
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
{
this.ctx = applicationContext;
}
public void startTenants()
{
AuthenticationUtil.setMtEnabled(true);
// initialise the tenant admin service and status of tenants (using attribute service)
// note: this requires that the repository schema has already been initialised
// register dictionary - to allow enable/disable tenant callbacks
register(dictionaryComponent);
if (tenantFileContentStore instanceof TenantDeployer)
{
// register file store - to allow enable/disable tenant callbacks
// note: tenantFileContentStore must be registed before dictionaryRepositoryBootstrap
register((TenantDeployer)tenantFileContentStore, 0);
}
UserTransaction userTransaction = transactionService.getUserTransaction();
try
{
authenticationContext.setSystemUserAsCurrentUser();
userTransaction.begin();
// bootstrap Tenant Service internal cache
List<Tenant> tenants = getAllTenants();
int enabledCount = 0;
int disabledCount = 0;
for (Tenant tenant : tenants)
{
if ((! (tenantFileContentStore instanceof AbstractTenantRoutingContentStore)) && (! tenantFileContentStore.getRootLocation().equals(tenant.getRootContentStoreDir())))
{
// eg. MT will not work with replicating-content-services-context.sample if tenants are not co-mingled
throw new AlfrescoRuntimeException("MT: cannot start tenants - TenantRoutingContentStore is not configured AND not all tenants use co-mingled content store");
}
if (tenant.isEnabled())
{
// this will also call tenant deployers registered so far ...
enableTenant(tenant.getTenantDomain(), true);
enabledCount++;
}
else
{
// explicitly disable, without calling disableTenant callback
disableTenant(tenant.getTenantDomain(), false);
disabledCount++;
}
}
userTransaction.commit();
if ((enabledCount+disabledCount) == 0)
{
AuthenticationUtil.setMtEnabled(false); // explicitly disable if there are no tenants
}
if (logger.isInfoEnabled() && ((enabledCount+disabledCount) > 0))
{
logger.info(String.format("Alfresco Multi-Tenant startup - %d enabled tenants, %d disabled tenants",
enabledCount, disabledCount));
}
else if (logger.isDebugEnabled())
{
logger.debug(String.format("Alfresco Multi-Tenant startup - %d enabled tenants, %d disabled tenants",
enabledCount, disabledCount));
}
}
catch(Throwable e)
{
// rollback the transaction
try { if (userTransaction != null) {userTransaction.rollback();} } catch (Exception ex) {}
throw new AlfrescoRuntimeException("Failed to bootstrap tenants", e);
}
finally
{
authenticationContext.clearCurrentSecurityContext();
}
}
public void stopTenants()
{
tenantDeployers.clear();
tenantDeployers = null;
AuthenticationUtil.setMtEnabled(false);
}
/**
* @see TenantAdminService.createTenant()
*/
public void createTenant(final String tenantDomain, final char[] tenantAdminRawPassword)
{
createTenant(tenantDomain, tenantAdminRawPassword, null);
}
/**
* @see TenantAdminService.createTenant()
*/
public void createTenant(String tenantDomainIn, final char[] tenantAdminRawPassword, String rootContentStoreDir)
{
ParameterCheck.mandatory("tenantAdminRawPassword", tenantAdminRawPassword);
final String tenantDomain = getTenantDomain(tenantDomainIn);
AuthenticationUtil.setMtEnabled(true); // in case this is the 1st tenant
long start = System.currentTimeMillis();
initTenant(tenantDomain, rootContentStoreDir);
try
{
// note: runAs would cause auditable property "creator" to be "admin" instead of "System@xxx"
AuthenticationUtil.pushAuthentication();
AuthenticationUtil.setFullyAuthenticatedUser(getSystemUser(tenantDomain));
dictionaryComponent.init();
if (tenantFileContentStore instanceof TenantDeployer)
{
((TenantDeployer)tenantFileContentStore).init();
}
// create tenant-specific stores
ImporterBootstrap userImporterBootstrap = (ImporterBootstrap)ctx.getBean("userBootstrap-mt");
bootstrapUserTenantStore(userImporterBootstrap, tenantDomain, tenantAdminRawPassword);
ImporterBootstrap systemImporterBootstrap = (ImporterBootstrap)ctx.getBean("systemBootstrap-mt");
bootstrapSystemTenantStore(systemImporterBootstrap, tenantDomain);
// deprecated
ImporterBootstrap versionImporterBootstrap = (ImporterBootstrap)ctx.getBean("versionBootstrap-mt");
bootstrapVersionTenantStore(versionImporterBootstrap, tenantDomain);
ImporterBootstrap version2ImporterBootstrap = (ImporterBootstrap)ctx.getBean("version2Bootstrap-mt");
bootstrapVersionTenantStore(version2ImporterBootstrap, tenantDomain);
ImporterBootstrap spacesArchiveImporterBootstrap = (ImporterBootstrap)ctx.getBean("spacesArchiveBootstrap-mt");
bootstrapSpacesArchiveTenantStore(spacesArchiveImporterBootstrap, tenantDomain);
ImporterBootstrap spacesImporterBootstrap = (ImporterBootstrap)ctx.getBean("spacesBootstrap-mt");
bootstrapSpacesTenantStore(spacesImporterBootstrap, tenantDomain);
thumbnailRegistry.initThumbnailDefinitions();
// notify listeners that tenant has been created & hence enabled
for (TenantDeployer tenantDeployer : tenantDeployers)
{
tenantDeployer.onEnableTenant();
}
// bootstrap workflows
for (WorkflowDeployer workflowDeployer : workflowDeployers)
{
workflowDeployer.init();
}
// bootstrap modules (if any)
moduleService.startModules();
}
finally
{
AuthenticationUtil.popAuthentication();
}
if (logger.isInfoEnabled())
{
logger.info("Tenant created: " + tenantDomain + " in "+(System.currentTimeMillis()-start)+ " ms");
}
}
/**
* Export tenant - equivalent to the tenant admin running a 'complete repo' export from the Web Client Admin
*/
public void exportTenant(String tenantDomain, final File directoryDestination)
{
final String lowerTenantDomain = getTenantDomain(tenantDomain);
AuthenticationUtil.runAs(new RunAsWork<Object>()
{
public Object doWork()
{
repositoryExporterService.export(directoryDestination, lowerTenantDomain);
return null;
}
}, getSystemUser(tenantDomain));
logger.info("Tenant exported: " + tenantDomain);
}
/**
* Create tenant by restoring from a complete repository export. This is equivalent to a bootstrap import using restore-context.xml.
*/
public void importTenant(final String tenantDomainIn, final File directorySource, String contentRoot)
{
final String tenantDomain = getTenantDomain(tenantDomainIn);
initTenant(tenantDomain, contentRoot);
try
{
// note: runAs would cause auditable property "creator" to be "admin" instead of "System@xxx"
AuthenticationUtil.pushAuthentication();
AuthenticationUtil.setFullyAuthenticatedUser(getSystemUser(tenantDomain));
dictionaryComponent.init();
if (tenantFileContentStore instanceof TenantDeployer)
{
((TenantDeployer)tenantFileContentStore).init();
}
// import tenant-specific stores
importBootstrapUserTenantStore(tenantDomain, directorySource);
importBootstrapSystemTenantStore(tenantDomain, directorySource);
importBootstrapVersionTenantStore(tenantDomain, directorySource);
importBootstrapSpacesArchiveTenantStore(tenantDomain, directorySource);
importBootstrapSpacesModelsTenantStore(tenantDomain, directorySource);
importBootstrapSpacesTenantStore(tenantDomain, directorySource);
thumbnailRegistry.initThumbnailDefinitions();
// notify listeners that tenant has been created & hence enabled
for (TenantDeployer tenantDeployer : tenantDeployers)
{
tenantDeployer.onEnableTenant();
}
// bootstrap workflows
for (WorkflowDeployer workflowDeployer : workflowDeployers)
{
workflowDeployer.init();
}
// bootstrap modules (if any)
moduleService.startModules();
}
finally
{
AuthenticationUtil.popAuthentication();
}
logger.info("Tenant imported: " + tenantDomain);
}
public boolean existsTenant(String tenantDomain)
{
// Check that all the passed values are not null
ParameterCheck.mandatory("tenantDomain", tenantDomain);
tenantDomain = getTenantDomain(tenantDomain);
return (getTenantAttributes(tenantDomain) != null);
}
private Tenant getTenantAttributes(String tenantDomain)
{
TenantEntity tenantEntity = tenantAdminDAO.getTenant(tenantDomain);
if (tenantEntity == null)
{
return null;
}
else
{
Tenant tenant = new Tenant(tenantEntity.getTenantDomain(), tenantEntity.getEnabled(), tenantEntity.getContentRoot());
return tenant;
}
}
public void enableTenant(String tenantDomain)
{
tenantDomain = getTenantDomain(tenantDomain);
if (! existsTenant(tenantDomain))
{
throw new AuthenticationException("Tenant does not exist: " + tenantDomain);
}
if (isEnabledTenant(tenantDomain))
{
logger.warn("Tenant already enabled: " + tenantDomain);
}
enableTenant(tenantDomain, true);
}
private void enableTenant(String tenantDomain, boolean notifyTenantDeployers)
{
// Check that all the passed values are not null
ParameterCheck.mandatory("tenantDomain", tenantDomain);
TenantUpdateEntity tenantUpdateEntity = tenantAdminDAO.getTenantForUpdate(tenantDomain);
tenantUpdateEntity.setEnabled(true);
tenantAdminDAO.updateTenant(tenantUpdateEntity);
if (notifyTenantDeployers)
{
// notify listeners that tenant has been enabled
AuthenticationUtil.runAs(new RunAsWork<Object>()
{
public Object doWork()
{
for (TenantDeployer tenantDeployer : tenantDeployers)
{
tenantDeployer.onEnableTenant();
}
return null;
}
}, getSystemUser(tenantDomain));
}
logger.info("Tenant enabled: " + tenantDomain);
}
public void disableTenant(String tenantDomain)
{
tenantDomain = getTenantDomain(tenantDomain);
if (! existsTenant(tenantDomain))
{
throw new AuthenticationException("Tenant does not exist: " + tenantDomain);
}
if (! isEnabledTenant(tenantDomain))
{
logger.warn("Tenant already disabled: " + tenantDomain);
}
disableTenant(tenantDomain, true);
}
public void disableTenant(String tenantDomain, boolean notifyTenantDeployers)
{
tenantDomain = getTenantDomain(tenantDomain);
if (notifyTenantDeployers)
{
// notify listeners that tenant has been disabled
AuthenticationUtil.runAs(new RunAsWork<Object>()
{
public Object doWork()
{
for (TenantDeployer tenantDeployer : tenantDeployers)
{
tenantDeployer.onDisableTenant();
}
return null;
}
}, getSystemUser(tenantDomain));
}
// update tenant attributes / tenant cache - need to disable after notifying listeners (else they cannot disable)
TenantUpdateEntity tenantUpdateEntity = tenantAdminDAO.getTenantForUpdate(tenantDomain);
tenantUpdateEntity.setEnabled(false);
tenantAdminDAO.updateTenant(tenantUpdateEntity);
logger.info("Tenant disabled: " + tenantDomain);
}
public boolean isEnabledTenant(String tenantDomain)
{
// Check that all the passed values are not null
ParameterCheck.mandatory("tenantDomain", tenantDomain);
tenantDomain = getTenantDomain(tenantDomain);
Tenant tenant = getTenantAttributes(tenantDomain);
if (tenant != null)
{
return tenant.isEnabled();
}
return false;
}
protected String getRootContentStoreDir(String tenantDomain)
{
// Check that all the passed values are not null
ParameterCheck.mandatory("tenantDomain", tenantDomain);
Tenant tenant = getTenantAttributes(tenantDomain);
if (tenant != null)
{
return tenant.getRootContentStoreDir();
}
return null;
}
public Tenant getTenant(String tenantDomain)
{
tenantDomain = getTenantDomain(tenantDomain);
if (! existsTenant(tenantDomain))
{
throw new AuthenticationException("Tenant does not exist: " + tenantDomain);
}
return new Tenant(tenantDomain, isEnabledTenant(tenantDomain), getRootContentStoreDir(tenantDomain));
}
/**
* @see TenantAdminService.deleteTenant()
*/
public void deleteTenant(String tenantDomain)
{
tenantDomain = getTenantDomain(tenantDomain);
if (! existsTenant(tenantDomain))
{
throw new AuthenticationException("Tenant does not exist: " + tenantDomain);
}
else
{
try
{
AuthenticationUtil.runAs(new RunAsWork<Object>()
{
public Object doWork()
{
List<WorkflowDefinition> workflowDefs = workflowService.getDefinitions();
if (workflowDefs != null)
{
for (WorkflowDefinition workflowDef : workflowDefs)
{
workflowService.undeployDefinition(workflowDef.getId());
}
}
List<String> messageResourceBundles = repoAdminService.getMessageBundles();
if (messageResourceBundles != null)
{
for (String messageResourceBundle : messageResourceBundles)
{
repoAdminService.undeployMessageBundle(messageResourceBundle);
}
}
List<RepoModelDefinition> models = repoAdminService.getModels();
if (models != null)
{
for (RepoModelDefinition model : models)
{
repoAdminService.undeployModel(model.getRepoName());
}
}
return null;
}
}, getSystemUser(tenantDomain));
final String tenantAdminUser = getTenantAdminUser(tenantDomain);
// delete tenant-specific stores
nodeService.deleteStore(tenantService.getName(tenantAdminUser, new StoreRef(PROTOCOL_STORE_WORKSPACE, STORE_BASE_ID_SPACES)));
nodeService.deleteStore(tenantService.getName(tenantAdminUser, new StoreRef(PROTOCOL_STORE_ARCHIVE, STORE_BASE_ID_SPACES)));
nodeService.deleteStore(tenantService.getName(tenantAdminUser, new StoreRef(PROTOCOL_STORE_WORKSPACE, STORE_BASE_ID_VERSION1)));
nodeService.deleteStore(tenantService.getName(tenantAdminUser, new StoreRef(PROTOCOL_STORE_WORKSPACE, STORE_BASE_ID_VERSION2)));
nodeService.deleteStore(tenantService.getName(tenantAdminUser, new StoreRef(PROTOCOL_STORE_SYSTEM, STORE_BASE_ID_SYSTEM)));
nodeService.deleteStore(tenantService.getName(tenantAdminUser, new StoreRef(PROTOCOL_STORE_USER, STORE_BASE_ID_USER)));
// notify listeners that tenant has been deleted & hence disabled
AuthenticationUtil.runAs(new RunAsWork<Object>()
{
public Object doWork()
{
for (TenantDeployer tenantDeployer : tenantDeployers)
{
tenantDeployer.onDisableTenant();
}
return null;
}
}, getSystemUser(tenantDomain));
// remove tenant
tenantAdminDAO.deleteTenant(tenantDomain);
}
catch (Throwable t)
{
throw new AlfrescoRuntimeException("Failed to delete tenant: " + tenantDomain, t);
}
if (logger.isInfoEnabled())
{
logger.info("Tenant deleted: " + tenantDomain);
}
}
}
/**
* @see TenantAdminService.getAllTenants()
*/
public List<Tenant> getAllTenants()
{
List<TenantEntity> tenantEntities = tenantAdminDAO.listTenants();
List<Tenant> tenants = new ArrayList<Tenant>(tenantEntities.size());
for (TenantEntity tenantEntity : tenantEntities)
{
tenants.add(new Tenant(tenantEntity.getTenantDomain(), tenantEntity.getEnabled(), tenantEntity.getContentRoot()));
}
return tenants;
}
private void importBootstrapSystemTenantStore(String tenantDomain, File directorySource)
{
// Import Bootstrap (restore) Tenant-Specific Version Store
Properties bootstrapView = new Properties();
bootstrapView.put("path", "/");
bootstrapView.put("location", directorySource.getPath()+"/"+tenantDomain+"_system.acp");
List<Properties> bootstrapViews = new ArrayList<Properties>(1);
bootstrapViews.add(bootstrapView);
ImporterBootstrap systemImporterBootstrap = (ImporterBootstrap)ctx.getBean("systemBootstrap");
systemImporterBootstrap.setBootstrapViews(bootstrapViews);
bootstrapSystemTenantStore(systemImporterBootstrap, tenantDomain);
}
private void bootstrapSystemTenantStore(ImporterBootstrap systemImporterBootstrap, String tenantDomain)
{
// Bootstrap Tenant-Specific System Store
StoreRef bootstrapStoreRef = systemImporterBootstrap.getStoreRef();
StoreRef tenantBootstrapStoreRef = new StoreRef(bootstrapStoreRef.getProtocol(), tenantService.getName(bootstrapStoreRef.getIdentifier(), tenantDomain));
systemImporterBootstrap.setStoreUrl(tenantBootstrapStoreRef.toString());
// override default property (workspace://SpacesStore)
List<String> mustNotExistStoreUrls = new ArrayList<String>();
mustNotExistStoreUrls.add(new StoreRef(PROTOCOL_STORE_WORKSPACE, tenantService.getName(STORE_BASE_ID_USER, tenantDomain)).toString());
systemImporterBootstrap.setMustNotExistStoreUrls(mustNotExistStoreUrls);
systemImporterBootstrap.bootstrap();
// reset since systemImporter is singleton (hence reused)
systemImporterBootstrap.setStoreUrl(bootstrapStoreRef.toString());
logger.debug("Bootstrapped store: " + tenantService.getBaseName(tenantBootstrapStoreRef));
}
private void importBootstrapUserTenantStore(String tenantDomain, File directorySource)
{
// Import Bootstrap (restore) Tenant-Specific User Store
Properties bootstrapView = new Properties();
bootstrapView.put("path", "/");
bootstrapView.put("location", directorySource.getPath()+"/"+tenantDomain+"_users.acp");
List<Properties> bootstrapViews = new ArrayList<Properties>(1);
bootstrapViews.add(bootstrapView);
ImporterBootstrap userImporterBootstrap = (ImporterBootstrap)ctx.getBean("userBootstrap");
userImporterBootstrap.setBootstrapViews(bootstrapViews);
bootstrapUserTenantStore(userImporterBootstrap, tenantDomain, null);
}
private void bootstrapUserTenantStore(ImporterBootstrap userImporterBootstrap, String tenantDomain, char[] tenantAdminRawPassword)
{
// Bootstrap Tenant-Specific User Store
StoreRef bootstrapStoreRef = userImporterBootstrap.getStoreRef();
bootstrapStoreRef = new StoreRef(bootstrapStoreRef.getProtocol(), tenantService.getName(bootstrapStoreRef.getIdentifier(), tenantDomain));
userImporterBootstrap.setStoreUrl(bootstrapStoreRef.toString());
// override admin username property
Properties props = userImporterBootstrap.getConfiguration();
props.put("alfresco_user_store.adminusername", getTenantAdminUser(tenantDomain));
if (tenantAdminRawPassword != null)
{
String salt = null; // GUID.generate();
props.put("alfresco_user_store.adminpassword", passwordEncoder.encodePassword(new String(tenantAdminRawPassword), salt));
}
userImporterBootstrap.bootstrap();
logger.debug("Bootstrapped store: " + tenantService.getBaseName(bootstrapStoreRef));
}
private void importBootstrapVersionTenantStore(String tenantDomain, File directorySource)
{
// Import Bootstrap (restore) Tenant-Specific Version Store
Properties bootstrapView = new Properties();
bootstrapView.put("path", "/");
bootstrapView.put("location", directorySource.getPath()+"/"+tenantDomain+"_versions2.acp");
List<Properties> bootstrapViews = new ArrayList<Properties>(1);
bootstrapViews.add(bootstrapView);
ImporterBootstrap versionImporterBootstrap = (ImporterBootstrap)ctx.getBean("versionBootstrap");
versionImporterBootstrap.setBootstrapViews(bootstrapViews);
bootstrapVersionTenantStore(versionImporterBootstrap, tenantDomain);
}
private void bootstrapVersionTenantStore(ImporterBootstrap versionImporterBootstrap, String tenantDomain)
{
// Bootstrap Tenant-Specific Version Store
StoreRef bootstrapStoreRef = versionImporterBootstrap.getStoreRef();
bootstrapStoreRef = new StoreRef(bootstrapStoreRef.getProtocol(), tenantService.getName(bootstrapStoreRef.getIdentifier(), tenantDomain));
versionImporterBootstrap.setStoreUrl(bootstrapStoreRef.toString());
versionImporterBootstrap.bootstrap();
logger.debug("Bootstrapped store: " + tenantService.getBaseName(bootstrapStoreRef));
}
private void importBootstrapSpacesArchiveTenantStore(String tenantDomain, File directorySource)
{
// Import Bootstrap (restore) Tenant-Specific Spaces Archive Store
Properties bootstrapView = new Properties();
bootstrapView.put("path", "/");
bootstrapView.put("location", directorySource.getPath()+"/"+tenantDomain+"_spaces_archive.acp");
List<Properties> bootstrapViews = new ArrayList<Properties>(1);
bootstrapViews.add(bootstrapView);
ImporterBootstrap spacesArchiveImporterBootstrap = (ImporterBootstrap)ctx.getBean("spacesArchiveBootstrap");
spacesArchiveImporterBootstrap.setBootstrapViews(bootstrapViews);
bootstrapSpacesArchiveTenantStore(spacesArchiveImporterBootstrap, tenantDomain);
}
private void bootstrapSpacesArchiveTenantStore(ImporterBootstrap spacesArchiveImporterBootstrap, String tenantDomain)
{
// Bootstrap Tenant-Specific Spaces Archive Store
StoreRef bootstrapStoreRef = spacesArchiveImporterBootstrap.getStoreRef();
bootstrapStoreRef = new StoreRef(bootstrapStoreRef.getProtocol(), tenantService.getName(bootstrapStoreRef.getIdentifier(), tenantDomain));
spacesArchiveImporterBootstrap.setStoreUrl(bootstrapStoreRef.toString());
// override default property (archive://SpacesStore)
List<String> mustNotExistStoreUrls = new ArrayList<String>();
mustNotExistStoreUrls.add(bootstrapStoreRef.toString());
spacesArchiveImporterBootstrap.setMustNotExistStoreUrls(mustNotExistStoreUrls);
spacesArchiveImporterBootstrap.bootstrap();
logger.debug("Bootstrapped store: " + tenantService.getBaseName(bootstrapStoreRef));
}
private void importBootstrapSpacesModelsTenantStore(String tenantDomain, File directorySource)
{
// Import Bootstrap (restore) Tenant-Specific Spaces Store
Properties bootstrapView = new Properties();
bootstrapView.put("path", "/");
bootstrapView.put("location", directorySource.getPath()+"/"+tenantDomain+"_models.acp");
List<Properties> bootstrapViews = new ArrayList<Properties>(1);
bootstrapViews.add(bootstrapView);
ImporterBootstrap spacesImporterBootstrap = (ImporterBootstrap)ctx.getBean("spacesBootstrap");
spacesImporterBootstrap.setBootstrapViews(bootstrapViews);
bootstrapSpacesTenantStore(spacesImporterBootstrap, tenantDomain);
}
private void importBootstrapSpacesTenantStore(String tenantDomain, File directorySource)
{
// Import Bootstrap (restore) Tenant-Specific Spaces Store
Properties bootstrapView = new Properties();
bootstrapView.put("path", "/");
bootstrapView.put("location", directorySource.getPath()+"/"+tenantDomain+"_spaces.acp");
bootstrapView.put("uuidBinding", "UPDATE_EXISTING");
List<Properties> bootstrapViews = new ArrayList<Properties>(1);
bootstrapViews.add(bootstrapView);
ImporterBootstrap spacesImporterBootstrap = (ImporterBootstrap)ctx.getBean("spacesBootstrap");
spacesImporterBootstrap.setBootstrapViews(bootstrapViews);
spacesImporterBootstrap.setUseExistingStore(true);
bootstrapSpacesTenantStore(spacesImporterBootstrap, tenantDomain);
}
private void bootstrapSpacesTenantStore(ImporterBootstrap spacesImporterBootstrap, String tenantDomain)
{
// Bootstrap Tenant-Specific Spaces Store
StoreRef bootstrapStoreRef = spacesImporterBootstrap.getStoreRef();
bootstrapStoreRef = new StoreRef(bootstrapStoreRef.getProtocol(), tenantService.getName(bootstrapStoreRef.getIdentifier(), tenantDomain));
spacesImporterBootstrap.setStoreUrl(bootstrapStoreRef.toString());
// override admin username property
Properties props = spacesImporterBootstrap.getConfiguration();
props.put("alfresco_user_store.adminusername", getTenantAdminUser(tenantDomain));
// override guest username property
props.put("alfresco_user_store.guestusername", getTenantGuestUser(tenantDomain));
spacesImporterBootstrap.bootstrap();
// calculate any missing usages
UserUsageTrackingComponent userUsageTrackingComponent = (UserUsageTrackingComponent)ctx.getBean("userUsageTrackingComponent");
userUsageTrackingComponent.bootstrapInternal();
logger.debug("Bootstrapped store: " + tenantService.getBaseName(bootstrapStoreRef));
}
public void deployTenants(final TenantDeployer deployer, Log logger)
{
if (deployer == null)
{
throw new AlfrescoRuntimeException("Deployer must be provided");
}
if (logger == null)
{
throw new AlfrescoRuntimeException("Logger must be provided");
}
if (tenantService.isEnabled())
{
UserTransaction userTransaction = transactionService.getUserTransaction();
authenticationContext.setSystemUserAsCurrentUser();
List<Tenant> tenants = null;
try
{
userTransaction.begin();
tenants = getAllTenants();
userTransaction.commit();
}
catch(Throwable e)
{
// rollback the transaction
try { if (userTransaction != null) {userTransaction.rollback();} } catch (Exception ex) {}
throw new AlfrescoRuntimeException("Failed to get tenants", e);
}
finally
{
authenticationContext.clearCurrentSecurityContext();
}
for (Tenant tenant : tenants)
{
if (tenant.isEnabled())
{
try
{
// deploy within context of tenant domain
AuthenticationUtil.runAs(new RunAsWork<Object>()
{
public Object doWork()
{
// init the service within tenant context
deployer.init();
return null;
}
}, getSystemUser(tenant.getTenantDomain()));
}
catch (Throwable e)
{
logger.error("Deployment failed" + e);
StringWriter stringWriter = new StringWriter();
e.printStackTrace(new PrintWriter(stringWriter));
logger.error(stringWriter.toString());
// tenant deploy failure should not necessarily affect other tenants
}
}
}
}
}
public void undeployTenants(final TenantDeployer deployer, Log logger)
{
if (deployer == null)
{
throw new AlfrescoRuntimeException("Deployer must be provided");
}
if (logger == null)
{
throw new AlfrescoRuntimeException("Logger must be provided");
}
if (tenantService.isEnabled())
{
UserTransaction userTransaction = transactionService.getUserTransaction();
authenticationContext.setSystemUserAsCurrentUser();
List<Tenant> tenants = null;
try
{
userTransaction.begin();
tenants = getAllTenants();
userTransaction.commit();
}
catch(Throwable e)
{
// rollback the transaction
try { if (userTransaction != null) {userTransaction.rollback();} } catch (Exception ex) {}
try {authenticationContext.clearCurrentSecurityContext(); } catch (Exception ex) {}
throw new AlfrescoRuntimeException("Failed to get tenants", e);
}
try
{
AuthenticationUtil.pushAuthentication();
for (Tenant tenant : tenants)
{
if (tenant.isEnabled())
{
try
{
// undeploy within context of tenant domain
AuthenticationUtil.runAs(new RunAsWork<Object>()
{
public Object doWork()
{
// destroy the service within tenant context
deployer.destroy();
return null;
}
}, getSystemUser(tenant.getTenantDomain()));
}
catch (Throwable e)
{
logger.error("Undeployment failed" + e);
StringWriter stringWriter = new StringWriter();
e.printStackTrace(new PrintWriter(stringWriter));
logger.error(stringWriter.toString());
// tenant undeploy failure should not necessarily affect other tenants
}
}
}
}
finally
{
AuthenticationUtil.popAuthentication();
}
}
}
public void register(TenantDeployer deployer)
{
register(deployer, -1);
}
protected void register(TenantDeployer deployer, int position)
{
if (deployer == null)
{
throw new AlfrescoRuntimeException("Deployer must be provided");
}
if (! tenantDeployers.contains(deployer))
{
if (position == -1)
{
tenantDeployers.add(deployer);
}
else
{
tenantDeployers.add(position, deployer);
}
}
}
public void unregister(TenantDeployer deployer)
{
if (deployer == null)
{
throw new AlfrescoRuntimeException("TenantDeployer must be provided");
}
if (tenantDeployers != null)
{
tenantDeployers.remove(deployer);
}
}
public void register(WorkflowDeployer workflowDeployer)
{
if (workflowDeployer == null)
{
throw new AlfrescoRuntimeException("WorkflowDeployer must be provided");
}
if (! workflowDeployers.contains(workflowDeployer))
{
workflowDeployers.add(workflowDeployer);
}
}
public void resetCache(String tenantDomain)
{
if (existsTenant(tenantDomain))
{
if (isEnabledTenant(tenantDomain))
{
enableTenant(tenantDomain);
}
else
{
disableTenant(tenantDomain);
}
}
else
{
throw new AuthenticationException("No such tenant " + tenantDomain);
}
}
private void initTenant(String tenantDomain, String rootContentStoreDir)
{
validateTenantName(tenantDomain);
if (existsTenant(tenantDomain))
{
throw new AlfrescoRuntimeException("Tenant already exists: " + tenantDomain);
}
if (rootContentStoreDir != null)
{
if (! (tenantFileContentStore instanceof AbstractTenantRoutingContentStore))
{
// eg. MT will not work with replicating-content-services-context.sample
throw new AlfrescoRuntimeException("MT: cannot initialse tenant - TenantRoutingContentStore is not configured AND tenant is not using co-mingled content store (ie. default root location)");
}
File tenantRootDir = new File(rootContentStoreDir);
if ((tenantRootDir.exists()) && (tenantRootDir.list().length != 0))
{
logger.warn("Tenant root directory is not empty: " + rootContentStoreDir);
}
}
if (rootContentStoreDir == null)
{
rootContentStoreDir = tenantFileContentStore.getRootLocation();
}
// init - need to enable tenant (including tenant service) before stores bootstrap
TenantEntity tenantEntity = new TenantEntity(tenantDomain);
tenantEntity.setEnabled(true);
tenantEntity.setContentRoot(rootContentStoreDir);
tenantAdminDAO.createTenant(tenantEntity);
}
private void validateTenantName(String tenantDomain)
{
ParameterCheck.mandatory("tenantDomain", tenantDomain);
if (tenantDomain.length() > MAX_LEN)
{
throw new IllegalArgumentException(tenantDomain + " is not a valid tenant name (must be less than " + MAX_LEN + " characters)");
}
if (! Pattern.matches(REGEX_CONTAINS_ALPHA, tenantDomain))
{
throw new IllegalArgumentException(tenantDomain + " is not a valid tenant name (must contain at least one alpha character)");
}
String[] dnsLabels = tenantDomain.split("\\.");
if (dnsLabels.length != 0)
{
for (int i = 0; i < dnsLabels.length; i++)
{
if (! Pattern.matches(REGEX_VALID_DNS_LABEL, dnsLabels[i]))
{
throw new IllegalArgumentException(dnsLabels[i] + " is not a valid DNS label (must match " + REGEX_VALID_DNS_LABEL + ")");
}
}
}
else
{
if (! Pattern.matches(REGEX_VALID_DNS_LABEL, tenantDomain))
{
throw new IllegalArgumentException(tenantDomain + " is not a valid DNS label (must match " + REGEX_VALID_DNS_LABEL + ")");
}
}
}
// tenant deployer/user services delegated to tenant service
public boolean isEnabled()
{
return tenantService.isEnabled();
}
public String getCurrentUserDomain()
{
return tenantService.getCurrentUserDomain();
}
public String getUserDomain(String username)
{
return tenantService.getUserDomain(username);
}
public String getBaseNameUser(String username)
{
return tenantService.getBaseNameUser(username);
}
public String getDomainUser(String baseUsername, String tenantDomain)
{
tenantDomain = getTenantDomain(tenantDomain);
return tenantService.getDomainUser(baseUsername, tenantDomain);
}
public String getDomain(String name)
{
name = getTenantDomain(name);
return tenantService.getDomain(name);
}
// local helpers
public String getBaseAdminUser()
{
// default for backwards compatibility only - eg. upgrade of existing MT instance (mt-admin-context.xml.sample)
if (baseAdminUsername != null)
{
return baseAdminUsername;
}
return getBaseNameUser(AuthenticationUtil.getAdminUserName());
}
private String getSystemUser(String tenantDomain)
{
return tenantService.getDomainUser(AuthenticationUtil.getSystemUserName(), tenantDomain);
}
private String getTenantAdminUser(String tenantDomain)
{
return tenantService.getDomainUser(getBaseAdminUser(), tenantDomain);
}
private String getTenantGuestUser(String tenantDomain)
{
return authenticationContext.getGuestUserName(tenantDomain);
}
protected String getTenantDomain(String tenantDomain)
{
ParameterCheck.mandatory("tenantDomain", tenantDomain);
return tenantDomain.toLowerCase(I18NUtil.getLocale());
}
}