mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-10-22 15:12:38 +00:00
ab4ca7177f
51903 to 54309 git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@54310 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
1109 lines
40 KiB
Java
1109 lines
40 KiB
Java
/*
|
|
* Copyright (C) 2005-2011 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.site;
|
|
|
|
import static org.junit.Assert.fail;
|
|
|
|
import java.io.File;
|
|
import java.io.PrintStream;
|
|
import java.util.Set;
|
|
|
|
import javax.transaction.SystemException;
|
|
import javax.transaction.UserTransaction;
|
|
|
|
import org.alfresco.model.ContentModel;
|
|
import org.alfresco.repo.security.authentication.AuthenticationComponent;
|
|
import org.alfresco.repo.security.authentication.AuthenticationUtil;
|
|
import org.alfresco.service.cmr.repository.DuplicateChildNodeNameException;
|
|
import org.alfresco.service.cmr.security.AuthorityService;
|
|
import org.alfresco.service.cmr.security.AuthorityType;
|
|
import org.alfresco.service.cmr.security.MutableAuthenticationService;
|
|
import org.alfresco.service.cmr.security.PersonService;
|
|
import org.alfresco.service.cmr.site.SiteService;
|
|
import org.alfresco.service.cmr.site.SiteVisibility;
|
|
import org.alfresco.service.transaction.TransactionService;
|
|
import org.alfresco.util.ApplicationContextHelper;
|
|
import org.alfresco.util.PropertyMap;
|
|
import org.junit.After;
|
|
import org.junit.AfterClass;
|
|
import org.junit.Before;
|
|
import org.junit.BeforeClass;
|
|
import org.junit.Test;
|
|
import org.springframework.context.ApplicationContext;
|
|
|
|
/**
|
|
* Site service unit test that targets HUGE numbers of sites
|
|
*
|
|
* @author Alan Davis
|
|
*/
|
|
public class SiteServiceTestHuge
|
|
{
|
|
private enum Allocation
|
|
{
|
|
/**
|
|
* Allocate source (groups) to target (sites) on a round robin basis
|
|
* until all targets (sites) have been allocated a single source (group).
|
|
*
|
|
* Some source (groups) might have been allocated to more than one target
|
|
* (site) or none at all.
|
|
**/
|
|
ROUND_ROBIN_TO_TARGET,
|
|
|
|
/**
|
|
* Allocate source (users) to target (groups) on a round robin basis
|
|
* until all source (users) have been allocated a target (group).
|
|
*
|
|
* Some target (groups) might have been allocated to more than one source
|
|
* (user) or none at all.
|
|
**/
|
|
ROUND_ROBIN_FROM_SOURCE,
|
|
|
|
/**
|
|
* Allocate source (users) to target (groups) on a round robin basis
|
|
* until all source (users) AND all target (groups) have been allocated
|
|
* to at least one a target (group) or one source (user).
|
|
*
|
|
* If there are more target (groups) than source (users)
|
|
* then some source (users) will be in more than one target (group).
|
|
*
|
|
* If there are more source (users) than target (groups) then some
|
|
* target (groups) will contain more than one source (user).
|
|
**/
|
|
ROUND_ROBIN_BOTH,
|
|
|
|
/**
|
|
* Allocate all source (users) to each target (group).
|
|
* OR
|
|
* Allocate all source (users) to each target (site).
|
|
* OR
|
|
* Allocate all source (groups) to each target (site).
|
|
**/
|
|
ALL_TO_EACH,
|
|
|
|
/** No allocation **/
|
|
NONE
|
|
}
|
|
|
|
private enum OnFailure
|
|
{
|
|
GIVE_UP,
|
|
KEEP_GOING
|
|
}
|
|
|
|
// Standard numbers of users, groups and sites
|
|
private static final int NUM_USERS = 100;
|
|
private static final int NUM_GROUPS = 60;
|
|
private static int NUM_SITES = 60000;
|
|
|
|
private static final String ADMIN_USER = "admin";
|
|
|
|
// Max times in ms for various activities
|
|
private static final long SECOND = 1000;
|
|
private static final long FIVE_SECONDS = SECOND * 5;
|
|
|
|
private static final long MAX_CREATE_USER_MS = FIVE_SECONDS;
|
|
private static final long MAX_CREATE_GROUP_MS = FIVE_SECONDS;
|
|
private static final long MAX_CREATE_SITE_MS = FIVE_SECONDS;
|
|
|
|
private static final long MAX_DELETE_USER_MS = FIVE_SECONDS;
|
|
private static final long MAX_DELETE_GROUP_MS = FIVE_SECONDS;
|
|
private static final long MAX_DELETE_SITE_MS = FIVE_SECONDS;
|
|
|
|
private static final long MAX_USER_TO_GROUP_MS = FIVE_SECONDS;
|
|
private static final long MAX_USER_TO_SITE_MS = FIVE_SECONDS;
|
|
private static final long MAX_GROUP_TO_SITE_MS = FIVE_SECONDS;
|
|
|
|
// Used to save having to check if users, groups and sites exist if already created by this test.
|
|
private static int usersCreated = 0;
|
|
private static int groupsCreated = 0;
|
|
private static int sitesCreated = 0;
|
|
|
|
private static ApplicationContext ctx = ApplicationContextHelper.getApplicationContext();
|
|
private static TransactionService transactionService = (TransactionService)ctx.getBean("TransactionService");
|
|
private static AuthenticationComponent authenticationComponent = (AuthenticationComponent)ctx.getBean("authenticationComponent");
|
|
private static MutableAuthenticationService authenticationService = (MutableAuthenticationService)ctx.getBean("authenticationService");
|
|
private static PersonService personService = (PersonService)ctx.getBean("PersonService");
|
|
private static AuthorityService authorityService = (AuthorityService)ctx.getBean("AuthorityService");
|
|
private static SiteService siteService = (SiteService)ctx.getBean("SiteService"); // Big 'S'
|
|
|
|
private static String logFilename;
|
|
private static PrintStream log;
|
|
|
|
@BeforeClass
|
|
public static void setUpBeforeClass() throws Exception
|
|
{
|
|
logFilename = "sites.log";
|
|
}
|
|
|
|
@AfterClass
|
|
public static void tearDownClass()
|
|
{
|
|
if (log != null)
|
|
{
|
|
log.close();
|
|
}
|
|
}
|
|
|
|
@Before
|
|
public void setUp() throws Exception
|
|
{
|
|
authenticationComponent.setCurrentUser(AuthenticationUtil.getAdminUserName());
|
|
}
|
|
|
|
@After
|
|
public void tearDown() throws Exception
|
|
{
|
|
authenticationComponent.clearCurrentSecurityContext();
|
|
}
|
|
|
|
private void log(String msg) throws Exception
|
|
{
|
|
System.out.println(msg);
|
|
if (logFilename != null)
|
|
{
|
|
if (log == null)
|
|
{
|
|
log = new PrintStream(new File(logFilename));
|
|
}
|
|
log.println(msg);
|
|
}
|
|
}
|
|
|
|
// ------------------ main test helper methods --------------------
|
|
|
|
private void createAndAllocate(int userCount, int groupCount, int siteCount,
|
|
Allocation usersToGroups, Allocation usersToSites, Allocation groupsToSites)
|
|
throws Exception
|
|
{
|
|
createUsersGroupsAndSites(userCount, groupCount, siteCount);
|
|
allocateUsersToGroupsAndSites(userCount, groupCount, siteCount, usersToGroups,
|
|
usersToSites, groupsToSites);
|
|
}
|
|
|
|
private void createUsersGroupsAndSites(int userCount, int groupCount, int siteCount)
|
|
throws Exception
|
|
{
|
|
createUsers(userCount);
|
|
createGroups(groupCount);
|
|
createSites(siteCount, userCount, 0, OnFailure.GIVE_UP);
|
|
}
|
|
|
|
private void allocateUsersToGroupsAndSites(int userCount, int groupCount, int siteCount,
|
|
Allocation usersToGroups, Allocation usersToSites, Allocation groupsToSites)
|
|
throws Exception
|
|
{
|
|
if ((usersToGroups == Allocation.ALL_TO_EACH &&
|
|
usersToSites == Allocation.NONE &&
|
|
groupsToSites == Allocation.ROUND_ROBIN_TO_TARGET)
|
|
||
|
|
(usersToGroups == Allocation.NONE &&
|
|
usersToSites == Allocation.ALL_TO_EACH &&
|
|
groupsToSites == Allocation.NONE))
|
|
{
|
|
allocateUsersToGroups(userCount, groupCount, usersToGroups);
|
|
allocateUsersToSites(userCount, siteCount, usersToSites);
|
|
allocateGroupsToSites(groupCount, siteCount, groupsToSites, userCount, 0, OnFailure.GIVE_UP);
|
|
}
|
|
else
|
|
{
|
|
fail("Users are not able to see all sites or can see a site directly and via a group");
|
|
}
|
|
}
|
|
|
|
private void addMoreSites(int sitesToAdd, OnFailure onFailureAction) throws Exception
|
|
{
|
|
log("\n\n ADD "+sitesToAdd+" MORE SITES AND ADD A GROUP TO EACH");
|
|
Allocation groupsToSites = Allocation.ROUND_ROBIN_TO_TARGET;
|
|
int sitesAlreadyCreated = sitesCreated;
|
|
int siteCount = sitesAlreadyCreated + sitesToAdd;
|
|
|
|
long ms = System.currentTimeMillis();
|
|
createSites(siteCount, NUM_USERS, sitesAlreadyCreated, OnFailure.GIVE_UP);
|
|
allocateGroupsToSites(NUM_GROUPS, siteCount, groupsToSites, NUM_USERS, sitesAlreadyCreated, OnFailure.KEEP_GOING);
|
|
assertTime("Add more sites", sitesAlreadyCreated+1, sitesToAdd, ms, MAX_CREATE_SITE_MS+MAX_GROUP_TO_SITE_MS, onFailureAction, sitesToAdd);
|
|
}
|
|
|
|
private void assertTime(String what, int id1, int id2, long start, long max) throws Exception
|
|
{
|
|
assertTime(what, id1, id2, start, max, OnFailure.GIVE_UP, 1);
|
|
}
|
|
|
|
private void assertTime(String what, int id1, int id2, long start, long max, OnFailure onFailureAction, int blockSize) throws Exception
|
|
{
|
|
long ms = (System.currentTimeMillis() - start)/blockSize;
|
|
|
|
String msg = what+","+id1+(id2 > 0 ? ","+id2 : "")+","+ms+",ms"+((blockSize == 1) ? "" : " average for,"+blockSize);
|
|
log(msg);
|
|
if (ms > max && onFailureAction == OnFailure.GIVE_UP)
|
|
{
|
|
fail(msg+" is longer than "+max);
|
|
}
|
|
}
|
|
|
|
// ------------------ create N --------------------
|
|
|
|
// Creates users and removes extra ones
|
|
private void createUsers(int userCount) throws Exception
|
|
{
|
|
for (int userId=1; ; userId++)
|
|
{
|
|
String userName = getUserName(userId);
|
|
boolean exists = (userId <= usersCreated) || personService.personExists(userName);
|
|
|
|
if (userId <= userCount)
|
|
{
|
|
if (!exists)
|
|
{
|
|
long ms = System.currentTimeMillis();
|
|
createUser(userName);
|
|
assertTime("Create user", userId, -1, ms, MAX_CREATE_USER_MS);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!exists)
|
|
{
|
|
break;
|
|
}
|
|
long ms = System.currentTimeMillis();
|
|
deleteUser(userName);
|
|
assertTime("Delete user", userId, -1, ms, MAX_DELETE_USER_MS);
|
|
}
|
|
}
|
|
usersCreated = userCount;
|
|
}
|
|
|
|
// Creates groups and removes extra ones
|
|
private void createGroups(int groupCount) throws Exception
|
|
{
|
|
for (int groupId=1; ; groupId++)
|
|
{
|
|
String groupName = getGroupName(groupId);
|
|
String groupAuthorityName = authorityService.getName(AuthorityType.GROUP, groupName);
|
|
boolean exists = (groupId <= groupsCreated) || authorityService.authorityExists(groupAuthorityName);
|
|
|
|
if (groupId <= groupCount)
|
|
{
|
|
if (!exists)
|
|
{
|
|
long ms = System.currentTimeMillis();
|
|
createGroup(groupName);
|
|
assertTime("Create group", groupId, -1, ms, MAX_CREATE_GROUP_MS);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!exists)
|
|
{
|
|
break;
|
|
}
|
|
long ms = System.currentTimeMillis();
|
|
deleteGroup(groupName);
|
|
assertTime("Delete group", groupId, -1, ms, MAX_DELETE_GROUP_MS);
|
|
}
|
|
}
|
|
groupsCreated = groupCount;
|
|
}
|
|
|
|
// Creates sites and removes extra ones
|
|
private void createSites(int siteCount, int userCount, int sitesAlreadyCreated, OnFailure onFailureAction) throws Exception
|
|
{
|
|
for (int siteId=sitesAlreadyCreated+1; ; siteId++)
|
|
{
|
|
String siteName = getSiteName(siteId);
|
|
boolean exists = (siteId <= sitesCreated) || siteService.getSite(siteName) != null;
|
|
|
|
if (siteId <= siteCount)
|
|
{
|
|
if (!exists)
|
|
{
|
|
String siteOwnerUserName = getSiteOwnerUserName(siteId, userCount);
|
|
creatSite(siteId, siteOwnerUserName, onFailureAction);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!exists)
|
|
{
|
|
if (siteId >= siteCount + 1)
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
long ms = System.currentTimeMillis();
|
|
deleteSite(siteName, null);
|
|
assertTime("Delete site", siteId, -1, ms, MAX_DELETE_SITE_MS);
|
|
}
|
|
}
|
|
}
|
|
sitesCreated = siteCount;
|
|
}
|
|
|
|
private void deleteSites(int fromSiteId, int toSiteId, OnFailure onFailureAction) throws Exception
|
|
{
|
|
log("\n\n TIDY UP: DELETE SITES "+fromSiteId+" TO "+toSiteId);
|
|
for (int siteId = fromSiteId; siteId <= toSiteId; siteId++)
|
|
{
|
|
try
|
|
{
|
|
deleteSite(siteId, null, onFailureAction);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
// move on
|
|
}
|
|
}
|
|
sitesCreated = fromSiteId-1;
|
|
}
|
|
|
|
// ------------------ create 1 --------------------
|
|
|
|
private void createUser(String userName) throws Exception
|
|
{
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
txn.begin();
|
|
|
|
authenticationService.createAuthentication(userName, userName.toCharArray());
|
|
|
|
PropertyMap ppOne = new PropertyMap(4);
|
|
ppOne.put(ContentModel.PROP_USERNAME, userName);
|
|
ppOne.put(ContentModel.PROP_FIRSTNAME, userName.substring(0, userName.length()-4));
|
|
ppOne.put(ContentModel.PROP_LASTNAME, "user");
|
|
ppOne.put(ContentModel.PROP_EMAIL, userName + "@email.com");
|
|
ppOne.put(ContentModel.PROP_JOBTITLE, "jobTitle");
|
|
|
|
personService.createPerson(ppOne);
|
|
|
|
txn.commit();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
txn.rollback();
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
private void createGroup(String groupName) throws Exception
|
|
{
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
txn.begin();
|
|
|
|
authorityService.createAuthority(AuthorityType.GROUP, groupName);
|
|
|
|
txn.commit();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
txn.rollback();
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
private void creatSite(int siteId, String doAsUser, OnFailure onFailureAction) throws Exception
|
|
{
|
|
String siteName = getSiteName(siteId);
|
|
long ms = System.currentTimeMillis();
|
|
creatSite(siteName, doAsUser);
|
|
assertTime("Create site", siteId, -1, ms, MAX_CREATE_SITE_MS, onFailureAction, 1);
|
|
}
|
|
|
|
private void creatSite(String siteName, String doAsUser) throws Exception
|
|
{
|
|
String currentUser = authenticationComponent.getCurrentUserName();
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
if (doAsUser != null)
|
|
authenticationComponent.setCurrentUser(doAsUser);
|
|
txn.begin();
|
|
|
|
if (siteService.getSite(siteName) == null)
|
|
{
|
|
String sitePreset = "site-dashboard";
|
|
siteService.createSite(sitePreset, siteName, "Title for " + siteName, "Description for "
|
|
+ siteName, SiteVisibility.PUBLIC);
|
|
|
|
// TODO Should do the following rather than the createContainers - not sure how
|
|
// Map<String, String> tokens = new HashMap<String, String>();
|
|
// tokens.put("siteid", siteName);
|
|
// presetsManager.constructPreset(tokens, tokens);
|
|
siteService.createContainer(siteName, "documentLibrary", ContentModel.TYPE_FOLDER, null);
|
|
siteService.createContainer(siteName, "links", ContentModel.TYPE_FOLDER, null);
|
|
}
|
|
|
|
txn.commit();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
try
|
|
{
|
|
txn.rollback();
|
|
}
|
|
catch (Exception e2)
|
|
{
|
|
}
|
|
throw e;
|
|
}
|
|
finally
|
|
{
|
|
authenticationComponent.setCurrentUser(currentUser);
|
|
}
|
|
}
|
|
|
|
// ------------------ delete 1 --------------------
|
|
|
|
private void deleteUser(String userName) throws Exception
|
|
{
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
txn.begin();
|
|
|
|
personService.deletePerson(userName);
|
|
|
|
txn.commit();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
txn.rollback();
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
private void deleteGroup(String groupName) throws Exception
|
|
{
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
txn.begin();
|
|
|
|
String groupAuthorityName = authorityService.getName(AuthorityType.GROUP, groupName);
|
|
authorityService.deleteAuthority(groupAuthorityName, true);
|
|
|
|
txn.commit();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
txn.rollback();
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
private void deleteSite(int siteId, String doAsUser, OnFailure onFailureAction) throws Exception
|
|
{
|
|
String siteName = getSiteName(siteId);
|
|
long ms = System.currentTimeMillis();
|
|
deleteSite(siteName, doAsUser);
|
|
assertTime("Delete site", siteId, -1, ms, MAX_DELETE_SITE_MS, onFailureAction, 1);
|
|
}
|
|
|
|
private void deleteSite(String siteName, String doAsUser) throws Exception
|
|
{
|
|
String currentUser = authenticationComponent.getCurrentUserName();
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
if (doAsUser != null)
|
|
authenticationComponent.setCurrentUser(doAsUser);
|
|
txn.begin();
|
|
|
|
siteService.deleteSite(siteName);
|
|
|
|
txn.commit();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
try
|
|
{
|
|
txn.rollback();
|
|
}
|
|
catch (Exception e2)
|
|
{
|
|
}
|
|
throw e;
|
|
}
|
|
finally
|
|
{
|
|
authenticationComponent.setCurrentUser(currentUser);
|
|
}
|
|
}
|
|
|
|
// ------------------ allocate N --------------------
|
|
|
|
private void allocateUsersToGroups(int userCount, int groupCount, Allocation allocation)
|
|
throws Exception
|
|
{
|
|
if (allocation == Allocation.ALL_TO_EACH)
|
|
{
|
|
for (int userId = 1; userId <= userCount; userId++)
|
|
{
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
txn.begin();
|
|
Set<String> existingAuthorities = authorityService.getContainingAuthoritiesInZone(AuthorityType.GROUP,
|
|
getUserName(userId), AuthorityService.ZONE_APP_DEFAULT, null, -1);
|
|
for (int groupId = 1; groupId <= groupCount; groupId++)
|
|
{
|
|
if (!existingAuthorities.contains(authorityService.getName(AuthorityType.GROUP,
|
|
getGroupName(groupId))))
|
|
{
|
|
allocateUserToGroup(userId, groupId);
|
|
}
|
|
}
|
|
txn.commit();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
txn.rollback();
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int iterations, groupIncrement;
|
|
if (allocation == Allocation.ROUND_ROBIN_FROM_SOURCE)
|
|
{
|
|
iterations = userCount;
|
|
groupIncrement = 1;
|
|
}
|
|
else
|
|
{
|
|
iterations = groupCount;
|
|
groupIncrement = userCount;
|
|
}
|
|
int i=0;
|
|
OUTER: while (i < iterations)
|
|
{
|
|
for (int userId = 1; userId <= userCount; userId++)
|
|
{
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
txn.begin();
|
|
Set<String> existingAuthorities = authorityService.getContainingAuthoritiesInZone(AuthorityType.GROUP,
|
|
getUserName(userId), AuthorityService.ZONE_APP_DEFAULT, null, -1);
|
|
for (int groupId = userId; groupId <= groupCount; groupId += groupIncrement)
|
|
{
|
|
if (!existingAuthorities.contains(authorityService.getName(AuthorityType.GROUP,
|
|
getGroupName(groupId))))
|
|
{
|
|
allocateUserToGroup(userId, groupId);
|
|
}
|
|
if (++i >= iterations)
|
|
{
|
|
txn.commit();
|
|
break OUTER;
|
|
}
|
|
}
|
|
txn.commit();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
txn.rollback();
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void allocateUsersToSites(int userCount, int siteCount, Allocation allocation)
|
|
throws Exception
|
|
{
|
|
if (allocation == Allocation.ALL_TO_EACH)
|
|
{
|
|
for (int userId = 1; userId <= userCount; userId++)
|
|
{
|
|
for (int siteId = 1; siteId <= siteCount; siteId++)
|
|
{
|
|
allocateUserToSite(userId, siteId, userCount);
|
|
}
|
|
}
|
|
}
|
|
else if (allocation == Allocation.ROUND_ROBIN_TO_TARGET)
|
|
{
|
|
boolean sourceEnd = (allocation == Allocation.ROUND_ROBIN_TO_TARGET);
|
|
boolean targetEnd = (allocation == Allocation.ROUND_ROBIN_FROM_SOURCE);
|
|
for (int siteId = 1, userId = 1; ; siteId++, userId++)
|
|
{
|
|
if (userId > userCount)
|
|
{
|
|
if (targetEnd)
|
|
break;
|
|
sourceEnd = true;
|
|
userId = 1;
|
|
}
|
|
if (siteId > siteCount)
|
|
{
|
|
if (sourceEnd)
|
|
break;
|
|
targetEnd = true;
|
|
siteId = 1;
|
|
}
|
|
allocateUserToSite(userId, siteId, userCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void allocateGroupsToSites(int groupCount, int siteCount, Allocation allocation, int userCount,
|
|
int sitesAlreadyCreated, OnFailure onFailureAction) throws Exception
|
|
{
|
|
if (allocation == Allocation.ALL_TO_EACH)
|
|
{
|
|
for (int groupId = 1; groupId <= groupCount; groupId++)
|
|
{
|
|
for (int siteId = sitesAlreadyCreated+1; siteId <= siteCount; siteId++)
|
|
{
|
|
String doAsUser = getSiteOwnerUserName(siteId, userCount);
|
|
allocateGroupToSite(groupId, siteId, userCount, doAsUser, onFailureAction);
|
|
}
|
|
}
|
|
}
|
|
else if (allocation == Allocation.ROUND_ROBIN_TO_TARGET)
|
|
{
|
|
boolean sourceEnd = (allocation == Allocation.ROUND_ROBIN_TO_TARGET);
|
|
boolean targetEnd = (allocation == Allocation.ROUND_ROBIN_FROM_SOURCE);
|
|
int startGroupId = sitesAlreadyCreated % groupCount + 1;
|
|
for (int siteId = sitesAlreadyCreated+1, groupId = startGroupId; ; siteId++, groupId++)
|
|
{
|
|
if (groupId > groupCount)
|
|
{
|
|
if (targetEnd)
|
|
break;
|
|
sourceEnd = true;
|
|
groupId = 1;
|
|
}
|
|
if (siteId > siteCount)
|
|
{
|
|
if (sourceEnd)
|
|
break;
|
|
targetEnd = true;
|
|
siteId = 1;
|
|
}
|
|
String doAsUser = getSiteOwnerUserName(siteId, userCount);
|
|
allocateGroupToSite(groupId, siteId, userCount, doAsUser, onFailureAction);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void allocateUserToGroup(int userId, int groupId) throws Exception
|
|
{
|
|
String userName = getUserName(userId);
|
|
String groupName = getGroupName(groupId);
|
|
|
|
long ms = System.currentTimeMillis();
|
|
allocateUserToGroup(userName, groupName);
|
|
assertTime("Adding a user to a group", userId, groupId, ms, MAX_USER_TO_GROUP_MS);
|
|
}
|
|
|
|
private void allocateUserToSite(int userId, int siteId, int userCount) throws Exception
|
|
{
|
|
try
|
|
{
|
|
String userName = getUserName(userId);
|
|
String siteName = getSiteName(siteId);
|
|
String siteOwnerUserName = getSiteOwnerUserName(siteId, userCount);
|
|
|
|
long ms = System.currentTimeMillis();
|
|
allocateUserToSite(userName, siteName, siteOwnerUserName);
|
|
assertTime("Adding a user to a site", userId, siteId, ms, MAX_USER_TO_SITE_MS);
|
|
}
|
|
catch (DuplicateChildNodeNameException e)
|
|
{
|
|
// Already allocated.
|
|
}
|
|
}
|
|
|
|
private int getNextSiteToAddGroupTo(int firstSiteIdToCheck) throws Exception
|
|
{
|
|
String userName = getUserName(1);
|
|
Set<String> existingAuthorities = authorityService.getAuthoritiesForUser(userName);
|
|
int siteId = firstSiteIdToCheck;
|
|
for (; siteId <= NUM_SITES; siteId++)
|
|
{
|
|
String siteName = getSiteName(siteId);
|
|
String groupName = "GROUP_site_"+siteName;
|
|
if (!existingAuthorities.contains(groupName))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
log("Next site to add group to is "+siteId);
|
|
return siteId;
|
|
}
|
|
|
|
private void allocateGroupToSite(int firstSiteId, int userCount, String doAsUser, OnFailure onFailureAction, int blockSize) throws Exception
|
|
{
|
|
String currentUser = authenticationComponent.getCurrentUserName();
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
long ms1 = System.currentTimeMillis();
|
|
|
|
try
|
|
{
|
|
if (doAsUser != null)
|
|
authenticationComponent.setCurrentUser(doAsUser);
|
|
txn.begin();
|
|
for (int siteId = firstSiteId; siteId < firstSiteId+blockSize; siteId++)
|
|
{
|
|
try
|
|
{
|
|
int groupId = (siteId - 1) % NUM_GROUPS + 1;
|
|
String groupName = getGroupName(groupId);
|
|
String siteName = getSiteName(siteId);
|
|
|
|
long ms2 = System.currentTimeMillis();
|
|
String groupAuthorityName = authorityService.getName(AuthorityType.GROUP,
|
|
groupName);
|
|
siteService.setMembership(siteName, groupAuthorityName, SiteModel.SITE_COLLABORATOR);
|
|
assertTime("Adding a group to a site", groupId, siteId, ms2, MAX_GROUP_TO_SITE_MS, onFailureAction, 1);
|
|
}
|
|
catch (DuplicateChildNodeNameException e)
|
|
{
|
|
// Already allocated.
|
|
}
|
|
}
|
|
txn.commit();
|
|
assertTime(" Block Add", firstSiteId, 0, ms1, MAX_GROUP_TO_SITE_MS, onFailureAction, blockSize);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
txn.rollback();
|
|
throw e;
|
|
}
|
|
finally
|
|
{
|
|
authenticationComponent.setCurrentUser(currentUser);
|
|
}
|
|
}
|
|
|
|
private void allocateGroupToSite(int siteId, int userCount, String doAsUser, OnFailure onFailureAction) throws Exception
|
|
{
|
|
int groupId = (siteId-1) % NUM_GROUPS + 1;
|
|
allocateGroupToSite(groupId, siteId, userCount, doAsUser, onFailureAction);
|
|
}
|
|
|
|
private void allocateGroupToSite(int groupId, int siteId, int userCount, String doAsUser, OnFailure onFailureAction) throws Exception
|
|
{
|
|
try
|
|
{
|
|
String groupName = getGroupName(groupId);
|
|
String siteName = getSiteName(siteId);
|
|
|
|
long ms = System.currentTimeMillis();
|
|
allocateGroupToSite(groupName, siteName, doAsUser);
|
|
assertTime("Adding a group to a site", groupId, siteId, ms, MAX_GROUP_TO_SITE_MS, onFailureAction, 1);
|
|
}
|
|
catch (DuplicateChildNodeNameException e)
|
|
{
|
|
// Already allocated.
|
|
}
|
|
}
|
|
|
|
// ------------------ allocate 1 --------------------
|
|
|
|
private void allocateUserToGroup(String userName, String groupName) throws Exception
|
|
{
|
|
String groupAuthorityName = authorityService.getName(AuthorityType.GROUP, groupName);
|
|
authorityService.addAuthority(groupAuthorityName, userName);
|
|
}
|
|
|
|
private void allocateUserToSite(String userName, String siteName, String doAsUser)
|
|
throws Exception
|
|
{
|
|
setSiteMembership(userName, siteName, doAsUser);
|
|
}
|
|
|
|
private void allocateGroupToSite(String groupName, String siteName, String doAsUser)
|
|
throws Exception
|
|
{
|
|
String groupAuthorityName = authorityService.getName(AuthorityType.GROUP, groupName);
|
|
setSiteMembership(groupAuthorityName, siteName, doAsUser);
|
|
}
|
|
|
|
private void setSiteMembership(String authority, String siteName, String doAsUser)
|
|
throws SystemException, Exception
|
|
{
|
|
String currentUser = authenticationComponent.getCurrentUserName();
|
|
UserTransaction txn = transactionService.getUserTransaction();
|
|
try
|
|
{
|
|
if (doAsUser != null)
|
|
authenticationComponent.setCurrentUser(doAsUser);
|
|
txn.begin();
|
|
|
|
siteService.setMembership(siteName, authority, SiteModel.SITE_COLLABORATOR);
|
|
|
|
txn.commit();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
txn.rollback();
|
|
throw e;
|
|
}
|
|
finally
|
|
{
|
|
authenticationComponent.setCurrentUser(currentUser);
|
|
}
|
|
}
|
|
|
|
// ------------------ names --------------------
|
|
|
|
private String getUserName(int userId)
|
|
{
|
|
return getName("user", userId);
|
|
}
|
|
|
|
private String getGroupName(int groupId)
|
|
{
|
|
return getName("group", groupId);
|
|
}
|
|
|
|
private String getSiteName(int siteId)
|
|
{
|
|
return getName("site", siteId);
|
|
}
|
|
|
|
private String getName(String prefix, int id)
|
|
{
|
|
return new StringBuilder(prefix).append(id).toString();
|
|
}
|
|
|
|
private String getSiteOwnerUserName(int siteId, int userCount)
|
|
{
|
|
int ownerId = (siteId-1)%userCount+1;
|
|
return getUserName(ownerId);
|
|
}
|
|
|
|
// ------------------ Original Tests --------------------
|
|
|
|
// @Test
|
|
// public void testSingleGroup() throws Exception
|
|
// {
|
|
// Allocation usersToGroups = Allocation.ALL_TO_EACH;
|
|
// Allocation usersToSites = Allocation.NONE;
|
|
// Allocation groupsToSites = Allocation.ROUND_ROBIN_TO_TARGET;
|
|
//
|
|
// createAndAllocate(NUM_USERS, NUM_GROUPS, NUM_SITES, usersToGroups, usersToSites, groupsToSites);
|
|
// }
|
|
|
|
// @Test
|
|
// public void testMultipleGroups() throws Exception
|
|
// {
|
|
// Allocation usersToGroups = Allocation.ALL_TO_EACH;
|
|
// Allocation usersToSites = Allocation.NONE;
|
|
// Allocation groupsToSites = Allocation.ROUND_ROBIN_TO_TARGET;
|
|
//
|
|
// createAndAllocate(NUM_USERS, NUM_GROUPS, NUM_SITES, usersToGroups, usersToSites, groupsToSites);
|
|
// }
|
|
|
|
// @Test
|
|
// public void testNoGroups() throws Exception
|
|
// {
|
|
// Allocation usersToGroups = Allocation.NONE;
|
|
// Allocation usersToSites = Allocation.ALL_TO_EACH;
|
|
// Allocation groupsToSites = Allocation.NONE;
|
|
//
|
|
// createAndAllocate(NUM_USERS, NUM_GROUPS, NUM_SITES, usersToGroups, usersToSites, groupsToSites);
|
|
// }
|
|
|
|
// ------------------ Initial Data Load Tests --------------------
|
|
|
|
// @Test
|
|
// public void testInitClearDownAll() throws Exception
|
|
// {
|
|
// createUsersGroupsAndSites(0, 0, 0);
|
|
// }
|
|
|
|
// @Test
|
|
// public void testInitCreateUsersAndGroups() throws Exception
|
|
// {
|
|
// createUsers(NUM_USERS);
|
|
// createGroups(NUM_GROUPS);
|
|
// allocateUsersToGroups(NUM_USERS, NUM_GROUPS, Allocation.ALL_TO_EACH);
|
|
// }
|
|
|
|
@Test
|
|
public void testInit() throws Exception
|
|
{
|
|
createUsers(NUM_USERS);
|
|
createGroups(NUM_GROUPS);
|
|
allocateUsersToGroups(NUM_USERS, NUM_GROUPS, Allocation.ALL_TO_EACH);
|
|
|
|
createSites(NUM_SITES, NUM_USERS, 0, OnFailure.KEEP_GOING);
|
|
|
|
int blockSize = 10;
|
|
for (int siteId = getNextSiteToAddGroupTo(1); siteId <= NUM_SITES; siteId += blockSize)
|
|
{
|
|
allocateGroupToSite(siteId, NUM_USERS, ADMIN_USER, OnFailure.KEEP_GOING, blockSize);
|
|
}
|
|
}
|
|
|
|
// ------------------ Test to load data from cmd line --------------------
|
|
|
|
@Test
|
|
public void commandLine() throws Exception
|
|
{
|
|
String from = System.getProperty("from");
|
|
String to = System.getProperty("to");
|
|
String restart = System.getProperty("restart");
|
|
String action = System.getProperty("action");
|
|
logFilename = System.getProperty("log", "sites.log");
|
|
|
|
boolean usersOnly = "usersOnly".equalsIgnoreCase(action);
|
|
boolean sites = "sites".equalsIgnoreCase(action);
|
|
boolean groups = "groups".equalsIgnoreCase(action);
|
|
boolean test = "test".equalsIgnoreCase(action);
|
|
|
|
if ((usersOnly && (from != null || to != null || restart != null)) ||
|
|
(!usersOnly && (from == null || to == null || (action != null && !sites && !groups && !test))))
|
|
{
|
|
System.err.println(
|
|
"Usage: -Dfrom=<fromSiteId> -Dto=<toSiteId> [ -Dlog=<logFilename> ]\n" +
|
|
" -Daction=usersOnly [ -Dlog=<logFilename> ]\n" +
|
|
" -Daction=sites -Dfrom=<fromSiteId> -Dto=<toSiteId> [ -Dlog=<logFilename> ] [ -Drestart=<restartAtSiteId> ]\n" +
|
|
" -Daction=groups -Dfrom=<fromSiteId> -Dto=<toSiteId> [ -Dlog=<logFilename> ] [ -Drestart=<restartAtSiteId> ]" +
|
|
" -Daction=test -Dfrom=<fromSiteId> -Dto=<toSiteId> [ -Dlog=<logFilename> ] ");
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
int fromId = (from == null) ? 0 : Integer.parseInt(from);
|
|
NUM_SITES = (to == null) ? 0 : Integer.parseInt(to);
|
|
int restartFromId = (restart == null) ? fromId : Integer.parseInt(restart);
|
|
|
|
if (test)
|
|
{
|
|
testAddingSitesAndDelete(fromId, NUM_SITES);
|
|
}
|
|
else
|
|
{
|
|
if (action == null || usersOnly)
|
|
{
|
|
createUsers(NUM_USERS);
|
|
createGroups(NUM_GROUPS);
|
|
allocateUsersToGroups(NUM_USERS, NUM_GROUPS, Allocation.ALL_TO_EACH);
|
|
if (action == null)
|
|
{
|
|
sites = true;
|
|
}
|
|
}
|
|
|
|
if (sites)
|
|
{
|
|
createSites(NUM_SITES, NUM_USERS, restartFromId - 1, OnFailure.KEEP_GOING);
|
|
restartFromId = fromId;
|
|
groups = true;
|
|
}
|
|
|
|
if (groups)
|
|
{
|
|
int blockSize = 10;
|
|
for (int siteId = getNextSiteToAddGroupTo(restartFromId); siteId <= NUM_SITES; siteId += blockSize)
|
|
{
|
|
int size = Math.min(blockSize, NUM_SITES - siteId + 1);
|
|
allocateGroupToSite(siteId, NUM_USERS, ADMIN_USER, OnFailure.KEEP_GOING, size);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
finally
|
|
{
|
|
log("\n\n DONE");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Simplify running unit test from the command line.
|
|
*
|
|
* set SITE_CPATH=%TOMCAT_HOME%/lib/*;%TOMCAT_HOME%/endorsed/*;%TOMCAT_HOME%/webapps/alfresco/WEB-INF/lib/*;%TOMCAT_HOME%/webapps/alfresco/WEB-INF/classes;%TOMCAT_HOME%/shared/classes;
|
|
* java -Xmx2048m -XX:MaxPermSize=512M -classpath %SITE_CPATH% org.alfresco.repo.site.SiteServiceTestHuge ...
|
|
*/
|
|
public static void main(String args[])
|
|
{
|
|
org.junit.runner.JUnitCore.main(SiteServiceTestHuge.class.getName());
|
|
}
|
|
|
|
// ------------------ Tests Once Data Is Loaded --------------------
|
|
|
|
// @Test
|
|
// public void testAdding1000SitesInBlocksOf100() throws Exception
|
|
// {
|
|
// usersCreated = NUM_USERS;
|
|
// groupsCreated = NUM_GROUPS;
|
|
// sitesCreated = NUM_SITES;
|
|
//
|
|
// deleteSites(NUM_SITES+1, NUM_SITES+1000, OnFailure.KEEP_GOING);
|
|
//
|
|
// for (int i=1; i<=10; i++)
|
|
// {
|
|
// addMoreSites(100, OnFailure.GIVE_UP);
|
|
// }
|
|
//
|
|
// deleteSites(NUM_SITES+1, NUM_SITES+1000, OnFailure.KEEP_GOING);
|
|
// }
|
|
|
|
// @Test
|
|
// public void testAdding4SitesAndDelete() throws Exception
|
|
// {
|
|
// testAddingSitesAndDelete(NUM_SITES + 1, NUM_SITES + 100);
|
|
// }
|
|
|
|
public void testAddingSitesAndDelete(int fromSiteId, int toSiteId) throws Exception
|
|
{
|
|
usersCreated = NUM_USERS;
|
|
groupsCreated = NUM_GROUPS;
|
|
sitesCreated = fromSiteId - 1;
|
|
|
|
deleteSites(fromSiteId, toSiteId, OnFailure.KEEP_GOING);
|
|
|
|
log("\n\n CREATE SITES");
|
|
for (int siteId = fromSiteId; siteId <= toSiteId; siteId++)
|
|
{
|
|
String siteCreatorUser = getSiteOwnerUserName(siteId, NUM_USERS);
|
|
creatSite(siteId, siteCreatorUser, OnFailure.KEEP_GOING);
|
|
}
|
|
|
|
log("\n\n ADD GROUPS");
|
|
for (int siteId = fromSiteId; siteId <= toSiteId; siteId++)
|
|
{
|
|
String siteCreatorUser = getSiteOwnerUserName(siteId, NUM_USERS);
|
|
allocateGroupToSite(siteId, NUM_USERS, siteCreatorUser, OnFailure.KEEP_GOING);
|
|
}
|
|
|
|
log("\n\n DELETE");
|
|
for (int siteId = fromSiteId; siteId <= toSiteId; siteId++)
|
|
{
|
|
String siteCreatorUser = getSiteOwnerUserName(siteId, NUM_USERS);
|
|
deleteSite(siteId, siteCreatorUser, OnFailure.KEEP_GOING);
|
|
}
|
|
}
|
|
}
|