This is an automated email from the ASF dual-hosted git repository.
bhaisaab pushed a commit to branch 4.10
in repository https://gitbox.apache.org/repos/asf/cloudstack.git
commit d9b7b8cb6258082d1c0a8050fe1f7f0b3a91b8eb
Merge: cf6c949 542b7e6
Author: Rohit Yadav <rohit.ya...@shapeblue.com>
AuthorDate: Thu Aug 10 01:34:20 2017 +0200
Merge branch '4.9' into 4.10
Signed-off-by: Rohit Yadav <rohit.ya...@shapeblue.com>
.../cloud/configuration/ConfigurationManager.java | 14 +++
engine/schema/src/com/cloud/domain/DomainVO.java | 8 ++
.../configuration/ConfigurationManagerImpl.java | 40 ++++++--
server/src/com/cloud/user/DomainManagerImpl.java | 16 ++-
.../test/com/cloud/user/DomainManagerImplTest.java | 107 +++++++++++++++++----
.../cloud/vpc/MockConfigurationManagerImpl.java | 11 ++-
6 files changed, 166 insertions(+), 30 deletions(-)
diff --cc server/src/com/cloud/configuration/ConfigurationManagerImpl.java
index f6e040f,c85bac9..a936e97
mode 100755,100644..100755
--- a/server/src/com/cloud/configuration/ConfigurationManagerImpl.java
+++ b/server/src/com/cloud/configuration/ConfigurationManagerImpl.java
@@@ -34,13 -34,8 +34,6 @@@ import java.util.UUID
import javax.inject.Inject;
import javax.naming.ConfigurationException;
- import com.google.common.base.MoreObjects;
- import org.apache.commons.collections.CollectionUtils;
- import org.apache.commons.collections.MapUtils;
- import org.apache.cloudstack.engine.subsystem.api.storage.ZoneScope;
- import org.apache.cloudstack.storage.datastore.db.ImageStoreDao;
--import org.apache.log4j.Logger;
--
import org.apache.cloudstack.acl.SecurityChecker;
import org.apache.cloudstack.affinity.AffinityGroup;
import org.apache.cloudstack.affinity.AffinityGroupService;
@@@ -72,6 -67,6 +65,7 @@@ import org.apache.cloudstack.config.Con
import org.apache.cloudstack.context.CallContext;
import
org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
++import org.apache.cloudstack.engine.subsystem.api.storage.ZoneScope;
import org.apache.cloudstack.framework.config.ConfigDepot;
import org.apache.cloudstack.framework.config.ConfigKey;
import org.apache.cloudstack.framework.config.Configurable;
@@@ -86,11 -81,10 +80,15 @@@ import org.apache.cloudstack.region.Por
import org.apache.cloudstack.region.Region;
import org.apache.cloudstack.region.RegionVO;
import org.apache.cloudstack.region.dao.RegionDao;
++import org.apache.cloudstack.storage.datastore.db.ImageStoreDao;
+import org.apache.cloudstack.storage.datastore.db.ImageStoreDetailsDao;
+import org.apache.cloudstack.storage.datastore.db.ImageStoreVO;
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolDetailsDao;
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
+ import org.apache.commons.collections.CollectionUtils;
++import org.apache.commons.collections.MapUtils;
++import org.apache.log4j.Logger;
import com.cloud.alert.AlertManager;
import com.cloud.api.ApiDBUtils;
@@@ -221,8 -217,6 +219,8 @@@ import com.cloud.vm.dao.NicIpAliasDao
import com.cloud.vm.dao.NicIpAliasVO;
import com.cloud.vm.dao.NicSecondaryIpDao;
import com.cloud.vm.dao.VMInstanceDao;
-
++import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
public class ConfigurationManagerImpl extends ManagerBase implements
ConfigurationManager, ConfigurationService, Configurable {
public static final Logger s_logger =
Logger.getLogger(ConfigurationManagerImpl.class);
diff --cc server/src/com/cloud/user/DomainManagerImpl.java
index 09c4272,6efa121..60c48fa
--- a/server/src/com/cloud/user/DomainManagerImpl.java
+++ b/server/src/com/cloud/user/DomainManagerImpl.java
@@@ -23,9 -23,9 +23,6 @@@ import java.util.UUID
import javax.inject.Inject;
--import org.apache.log4j.Logger;
--import org.springframework.stereotype.Component;
--
import org.apache.cloudstack.api.command.admin.domain.ListDomainChildrenCmd;
import org.apache.cloudstack.api.command.admin.domain.ListDomainsCmd;
import org.apache.cloudstack.api.command.admin.domain.UpdateDomainCmd;
@@@ -34,9 -34,8 +31,12 @@@ import org.apache.cloudstack.engine.orc
import org.apache.cloudstack.framework.messagebus.MessageBus;
import org.apache.cloudstack.framework.messagebus.PublishScope;
import org.apache.cloudstack.region.RegionManager;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang.BooleanUtils;
++import org.apache.log4j.Logger;
++import org.springframework.stereotype.Component;
+ import com.cloud.configuration.ConfigurationManager;
import com.cloud.configuration.Resource.ResourceOwnerType;
import com.cloud.configuration.ResourceLimit;
import com.cloud.configuration.dao.ResourceCountDao;
@@@ -284,146 -276,89 +286,154 @@@ public class DomainManagerImpl extends
@Override
public boolean deleteDomain(DomainVO domain, Boolean cleanup) {
- // mark domain as inactive
- s_logger.debug("Marking domain id=" + domain.getId() + " as " +
Domain.State.Inactive + " before actually deleting it");
- domain.setState(Domain.State.Inactive);
- _domainDao.update(domain.getId(), domain);
- boolean rollBackState = false;
- boolean hasDedicatedResources = false;
+ GlobalLock lock = getGlobalLock("AccountCleanup");
+ if (lock == null) {
+ s_logger.debug("Couldn't get the global lock");
+ return false;
+ }
+
+ if (!lock.lock(30)) {
+ s_logger.debug("Couldn't lock the db");
+ return false;
+ }
try {
- long ownerId = domain.getAccountId();
- if ((cleanup != null) && cleanup.booleanValue()) {
- if (!cleanupDomain(domain.getId(), ownerId)) {
- rollBackState = true;
- CloudRuntimeException e =
- new CloudRuntimeException("Failed to clean up domain
resources and sub domains, delete failed on domain " + domain.getName() + "
(id: " +
- domain.getId() + ").");
- e.addProxyObject(domain.getUuid(), "domainId");
- throw e;
- }
- } else {
- //don't delete the domain if there are accounts set for
cleanup, or non-removed networks exist, or domain has dedicated resources
- List<Long> networkIds =
_networkDomainDao.listNetworkIdsByDomain(domain.getId());
- List<AccountVO> accountsForCleanup =
_accountDao.findCleanupsForRemovedAccounts(domain.getId());
- List<DedicatedResourceVO> dedicatedResources =
_dedicatedDao.listByDomainId(domain.getId());
- if (dedicatedResources != null &&
!dedicatedResources.isEmpty()) {
- s_logger.error("There are dedicated resources for the
domain " + domain.getId());
- hasDedicatedResources = true;
- }
- if (accountsForCleanup.isEmpty() && networkIds.isEmpty() &&
!hasDedicatedResources) {
- if (!_domainDao.remove(domain.getId())) {
- rollBackState = true;
- CloudRuntimeException e =
- new CloudRuntimeException("Delete failed on
domain " + domain.getName() + " (id: " + domain.getId() +
- "); Please make sure all users and sub
domains have been removed from the domain before deleting");
- e.addProxyObject(domain.getUuid(), "domainId");
- throw e;
- }
+ // mark domain as inactive
+ s_logger.debug("Marking domain id=" + domain.getId() + " as " +
Domain.State.Inactive + " before actually deleting it");
+ domain.setState(Domain.State.Inactive);
+ _domainDao.update(domain.getId(), domain);
+
+ try {
+ long ownerId = domain.getAccountId();
+ if (BooleanUtils.toBoolean(cleanup)) {
+ tryCleanupDomain(domain, ownerId);
} else {
- rollBackState = true;
- String msg = null;
- if (!accountsForCleanup.isEmpty()) {
- msg = accountsForCleanup.size() + " accounts to
cleanup";
- } else if (!networkIds.isEmpty()) {
- msg = networkIds.size() + " non-removed networks";
- } else if (hasDedicatedResources) {
- msg = "dedicated resources.";
- }
+
removeDomainWithNoAccountsForCleanupNetworksOrDedicatedResources(domain);
+ }
- CloudRuntimeException e = new
CloudRuntimeException("Can't delete the domain yet because it has " + msg);
++ if
(!_configMgr.releaseDomainSpecificVirtualRanges(domain.getId())) {
++ CloudRuntimeException e = new
CloudRuntimeException("Can't delete the domain yet because failed to release
domain specific virtual ip ranges");
+ e.addProxyObject(domain.getUuid(), "domainId");
+ throw e;
++ } else {
++ s_logger.debug("Domain specific Virtual IP ranges " + "
are successfully released as a part of domain id=" + domain.getId() + "
cleanup.");
+ }
- }
+
- if
(!_configMgr.releaseDomainSpecificVirtualRanges(domain.getId())) {
- CloudRuntimeException e = new CloudRuntimeException("Can't
delete the domain yet because failed to release domain specific virtual ip
ranges");
- e.addProxyObject(domain.getUuid(), "domainId");
- throw e;
- } else {
- s_logger.debug("Domain specific Virtual IP ranges " + " are
successfully released as a part of domain id=" + domain.getId() + " cleanup.");
+ cleanupDomainOfferings(domain.getId());
+ CallContext.current().putContextParameter(Domain.class,
domain.getUuid());
+ return true;
+ } catch (Exception ex) {
+ s_logger.error("Exception deleting domain with id " +
domain.getId(), ex);
+ if (ex instanceof CloudRuntimeException) {
+ rollbackDomainState(domain);
+ throw (CloudRuntimeException)ex;
+ }
+ else
+ return false;
}
+ }
+ finally {
+ lock.unlock();
+ }
+ }
- cleanupDomainOfferings(domain.getId());
- CallContext.current().putContextParameter(Domain.class,
domain.getUuid());
- _messageBus.publish(_name, MESSAGE_REMOVE_DOMAIN_EVENT,
PublishScope.LOCAL, domain);
- return true;
- } catch (Exception ex) {
- s_logger.error("Exception deleting domain with id " +
domain.getId(), ex);
- if (ex instanceof CloudRuntimeException)
- throw (CloudRuntimeException)ex;
- else
- return false;
- } finally {
- //when success is false
- if (rollBackState) {
- s_logger.debug("Changing domain id=" + domain.getId() + "
state back to " + Domain.State.Active +
- " because it can't be removed due to resources
referencing to it");
- domain.setState(Domain.State.Active);
- _domainDao.update(domain.getId(), domain);
- }
+ /**
+ * Roll back domain state to Active
+ * @param domain domain
+ */
+ protected void rollbackDomainState(DomainVO domain) {
+ s_logger.debug("Changing domain id=" + domain.getId() + " state back
to " + Domain.State.Active +
+ " because it can't be removed due to resources referencing to
it");
+ domain.setState(Domain.State.Active);
+ _domainDao.update(domain.getId(), domain);
+ }
+
+ /**
+ * Try cleaning up domain. If it couldn't throws CloudRuntimeException
+ * @param domain domain
+ * @param ownerId owner id
+ * @throws ConcurrentOperationException
+ * @throws ResourceUnavailableException
+ * @throws CloudRuntimeException when cleanupDomain
+ */
+ protected void tryCleanupDomain(DomainVO domain, long ownerId) throws
ConcurrentOperationException, ResourceUnavailableException,
CloudRuntimeException {
+ if (!cleanupDomain(domain.getId(), ownerId)) {
+ CloudRuntimeException e =
+ new CloudRuntimeException("Failed to clean up domain
resources and sub domains, delete failed on domain " + domain.getName() + "
(id: " +
+ domain.getId() + ").");
+ e.addProxyObject(domain.getUuid(), "domainId");
+ throw e;
+ }
+ }
+
+ /**
+ * First check domain resources before removing domain. There are 2 cases:
+ * <ol>
+ * <li>Domain doesn't have accounts for cleanup, non-removed networks, or
dedicated resources</li>
+ * <ul><li>Delete domain</li></ul>
+ * <li>Domain has one of the following: accounts set for cleanup,
non-removed networks, dedicated resources</li>
+ * <ul><li>Dont' delete domain</li><li>Fail operation</li></ul>
+ * </ol>
+ * @param domain domain to remove
+ * @throws CloudRuntimeException when case 2 or when domain cannot be
deleted on case 1
+ */
+ protected void
removeDomainWithNoAccountsForCleanupNetworksOrDedicatedResources(DomainVO
domain) {
+ boolean hasDedicatedResources = false;
+ List<Long> networkIds =
_networkDomainDao.listNetworkIdsByDomain(domain.getId());
+ List<AccountVO> accountsForCleanup =
_accountDao.findCleanupsForRemovedAccounts(domain.getId());
+ List<DedicatedResourceVO> dedicatedResources =
_dedicatedDao.listByDomainId(domain.getId());
+ if (CollectionUtils.isNotEmpty(dedicatedResources)) {
+ s_logger.error("There are dedicated resources for the domain " +
domain.getId());
+ hasDedicatedResources = true;
+ }
+ if (accountsForCleanup.isEmpty() && networkIds.isEmpty() &&
!hasDedicatedResources) {
+ publishRemoveEventsAndRemoveDomain(domain);
+ } else {
+ failRemoveOperation(domain, accountsForCleanup, networkIds,
hasDedicatedResources);
+ }
+ }
+
+ /**
+ * Fail domain remove operation including proper message
+ * @param domain domain
+ * @param accountsForCleanup domain accounts for cleanup
+ * @param networkIds domain network ids
+ * @param hasDedicatedResources indicates if domain has dedicated
resources
+ * @throws CloudRuntimeException including descriptive message indicating
the reason for failure
+ */
+ protected void failRemoveOperation(DomainVO domain, List<AccountVO>
accountsForCleanup, List<Long> networkIds, boolean hasDedicatedResources) {
+ String msg = null;
+ if (!accountsForCleanup.isEmpty()) {
+ msg = accountsForCleanup.size() + " accounts to cleanup";
+ } else if (!networkIds.isEmpty()) {
+ msg = networkIds.size() + " non-removed networks";
+ } else if (hasDedicatedResources) {
+ msg = "dedicated resources.";
+ }
+
+ CloudRuntimeException e = new CloudRuntimeException("Can't delete the
domain yet because it has " + msg);
+ e.addProxyObject(domain.getUuid(), "domainId");
+ throw e;
+ }
+
+ /**
+ * Publish pre-remove and remove domain events and remove domain
+ * @param domain domain to remove
+ * @throws CloudRuntimeException when domain cannot be removed
+ */
+ protected void publishRemoveEventsAndRemoveDomain(DomainVO domain) {
+ _messageBus.publish(_name, MESSAGE_PRE_REMOVE_DOMAIN_EVENT,
PublishScope.LOCAL, domain);
+ if (!_domainDao.remove(domain.getId())) {
+ CloudRuntimeException e =
+ new CloudRuntimeException("Delete failed on domain " +
domain.getName() + " (id: " + domain.getId() +
+ "); Please make sure all users and sub domains have been
removed from the domain before deleting");
+ e.addProxyObject(domain.getUuid(), "domainId");
+ throw e;
}
+ _messageBus.publish(_name, MESSAGE_REMOVE_DOMAIN_EVENT,
PublishScope.LOCAL, domain);
}
- private void cleanupDomainOfferings(Long domainId) {
+ protected void cleanupDomainOfferings(Long domainId) {
// delete the service and disk offerings associated with this domain
List<DiskOfferingVO> diskOfferingsForThisDomain =
_diskOfferingDao.listByDomainId(domainId);
for (DiskOfferingVO diskOffering : diskOfferingsForThisDomain) {
diff --cc server/test/com/cloud/user/DomainManagerImplTest.java
index 4c4fccc,b1b2b92..03ab340
--- a/server/test/com/cloud/user/DomainManagerImplTest.java
+++ b/server/test/com/cloud/user/DomainManagerImplTest.java
@@@ -17,42 -17,42 +17,50 @@@
package com.cloud.user;
- import com.cloud.configuration.dao.ResourceCountDao;
- import com.cloud.configuration.dao.ResourceLimitDao;
- import com.cloud.dc.DedicatedResourceVO;
- import com.cloud.dc.dao.DedicatedResourceDao;
- import com.cloud.domain.Domain;
- import com.cloud.domain.DomainVO;
- import com.cloud.domain.dao.DomainDao;
- import com.cloud.exception.InvalidParameterValueException;
- import com.cloud.exception.PermissionDeniedException;
- import com.cloud.network.dao.NetworkDomainDao;
- import com.cloud.projects.ProjectManager;
- import com.cloud.projects.dao.ProjectDao;
- import com.cloud.service.dao.ServiceOfferingDao;
- import com.cloud.storage.dao.DiskOfferingDao;
- import com.cloud.user.dao.AccountDao;
- import com.cloud.utils.db.GlobalLock;
- import com.cloud.utils.exception.CloudRuntimeException;
-
+import java.util.ArrayList;
+import java.util.List;
++import java.util.UUID;
+
++import org.apache.cloudstack.context.CallContext;
+import
org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
+import org.apache.cloudstack.framework.messagebus.MessageBus;
+import org.apache.cloudstack.framework.messagebus.PublishScope;
+import org.apache.cloudstack.region.RegionManager;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.Spy;
+import org.mockito.runners.MockitoJUnitRunner;
+
+ import com.cloud.configuration.ConfigurationManager;
+ import com.cloud.configuration.Resource.ResourceOwnerType;
+ import com.cloud.configuration.dao.ResourceCountDao;
+ import com.cloud.configuration.dao.ResourceLimitDao;
+ import com.cloud.dc.DedicatedResourceVO;
+ import com.cloud.dc.dao.DedicatedResourceDao;
+ import com.cloud.domain.Domain;
+ import com.cloud.domain.DomainVO;
+ import com.cloud.domain.dao.DomainDao;
++import com.cloud.exception.InvalidParameterValueException;
++import com.cloud.exception.PermissionDeniedException;
+ import com.cloud.network.dao.NetworkDomainDao;
+ import com.cloud.projects.ProjectManager;
+ import com.cloud.projects.dao.ProjectDao;
+ import com.cloud.service.ServiceOfferingVO;
+ import com.cloud.service.dao.ServiceOfferingDao;
+ import com.cloud.storage.DiskOfferingVO;
+ import com.cloud.storage.dao.DiskOfferingDao;
+ import com.cloud.user.dao.AccountDao;
+ import com.cloud.utils.db.Filter;
++import com.cloud.utils.db.GlobalLock;
+ import com.cloud.utils.db.SearchCriteria;
-import org.apache.cloudstack.context.CallContext;
-import
org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
-import org.apache.cloudstack.framework.messagebus.MessageBus;
-import org.apache.cloudstack.region.RegionManager;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-
-import javax.inject.Inject;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.UUID;
++import com.cloud.utils.exception.CloudRuntimeException;
+
@RunWith(MockitoJUnitRunner.class)
public class DomainManagerImplTest {
@Mock
@@@ -83,26 -83,10 +91,28 @@@
NetworkDomainDao _networkDomainDao;
@Mock
MessageBus _messageBus;
+ @Mock
+ ConfigurationManager _configMgr;
- DomainManagerImpl domainManager;
+ @Spy
+ @InjectMocks
+ DomainManagerImpl domainManager = new DomainManagerImpl();
+
+ @Mock
+ DomainVO domain;
+ @Mock
+ Account adminAccount;
+ @Mock
+ GlobalLock lock;
+
+ List<AccountVO> domainAccountsForCleanup;
+ List<Long> domainNetworkIds;
+ List<DedicatedResourceVO> domainDedicatedResources;
+
+ private static final long DOMAIN_ID = 3l;
+ private static final long ACCOUNT_ID = 1l;
+
+ private static boolean testDomainCleanup = false;
@Before
public void setup() throws NoSuchFieldException, SecurityException,
@@@ -164,64 -147,64 +174,125 @@@
Assert.assertEquals(domain, domainManager.findDomainByIdOrPath(1L,
"/validDomain/"));
}
+ @Test(expected=InvalidParameterValueException.class)
+ public void testDeleteDomainNullDomain() {
+ Mockito.when(_domainDao.findById(DOMAIN_ID)).thenReturn(null);
+ domainManager.deleteDomain(DOMAIN_ID, testDomainCleanup);
+ }
+
+ @Test(expected=PermissionDeniedException.class)
+ public void testDeleteDomainRootDomain() {
+
Mockito.when(_domainDao.findById(Domain.ROOT_DOMAIN)).thenReturn(domain);
+ domainManager.deleteDomain(Domain.ROOT_DOMAIN, testDomainCleanup);
+ }
+
+ @Test
+ public void testDeleteDomainNoCleanup() {
++
Mockito.when(_configMgr.releaseDomainSpecificVirtualRanges(Mockito.anyLong())).thenReturn(true);
+ domainManager.deleteDomain(DOMAIN_ID, testDomainCleanup);
+ Mockito.verify(domainManager).deleteDomain(domain, testDomainCleanup);
+
Mockito.verify(domainManager).removeDomainWithNoAccountsForCleanupNetworksOrDedicatedResources(domain);
+ Mockito.verify(domainManager).cleanupDomainOfferings(DOMAIN_ID);
+ Mockito.verify(lock).unlock();
+ }
+
+ @Test
+ public void
testRemoveDomainWithNoAccountsForCleanupNetworksOrDedicatedResourcesRemoveDomain()
{
+
domainManager.removeDomainWithNoAccountsForCleanupNetworksOrDedicatedResources(domain);
+
Mockito.verify(domainManager).publishRemoveEventsAndRemoveDomain(domain);
+ }
+
+ @Test(expected=CloudRuntimeException.class)
+ public void
testRemoveDomainWithNoAccountsForCleanupNetworksOrDedicatedResourcesDontRemoveDomain()
{
+ domainNetworkIds.add(2l);
+
domainManager.removeDomainWithNoAccountsForCleanupNetworksOrDedicatedResources(domain);
+ Mockito.verify(domainManager).failRemoveOperation(domain,
domainAccountsForCleanup, domainNetworkIds, false);
+ }
+
+ @Test
+ public void testPublishRemoveEventsAndRemoveDomainSuccessfulDelete() {
+ domainManager.publishRemoveEventsAndRemoveDomain(domain);
+ Mockito.verify(_messageBus).publish(Mockito.anyString(),
Matchers.eq(DomainManager.MESSAGE_PRE_REMOVE_DOMAIN_EVENT),
+ Matchers.eq(PublishScope.LOCAL), Matchers.eq(domain));
+ Mockito.verify(_messageBus).publish(Mockito.anyString(),
Matchers.eq(DomainManager.MESSAGE_REMOVE_DOMAIN_EVENT),
+ Matchers.eq(PublishScope.LOCAL), Matchers.eq(domain));
+ Mockito.verify(_domainDao).remove(DOMAIN_ID);
+ }
+
+ @Test(expected=CloudRuntimeException.class)
+ public void testPublishRemoveEventsAndRemoveDomainExceptionDelete() {
+ Mockito.when(_domainDao.remove(DOMAIN_ID)).thenReturn(false);
+ domainManager.publishRemoveEventsAndRemoveDomain(domain);
+ Mockito.verify(_messageBus).publish(Mockito.anyString(),
Matchers.eq(DomainManager.MESSAGE_PRE_REMOVE_DOMAIN_EVENT),
+ Matchers.eq(PublishScope.LOCAL), Matchers.eq(domain));
+ Mockito.verify(_messageBus,
Mockito.never()).publish(Mockito.anyString(),
Matchers.eq(DomainManager.MESSAGE_REMOVE_DOMAIN_EVENT),
+ Matchers.eq(PublishScope.LOCAL), Matchers.eq(domain));
+ Mockito.verify(_domainDao).remove(DOMAIN_ID);
+ }
+
+ @Test(expected=CloudRuntimeException.class)
+ public void testFailRemoveOperation() {
+ domainManager.failRemoveOperation(domain, domainAccountsForCleanup,
domainNetworkIds, true);
+ }
+
+ @Test
+ public void deleteDomain() {
+ DomainVO domain = new DomainVO();
+ domain.setId(20l);
+ domain.setAccountId(30l);
+ Account account = new AccountVO("testaccount", 1L, "networkdomain",
(short)0, "uuid");
+ UserVO user = new UserVO(1, "testuser", "password", "firstname",
"lastName", "email", "timezone", UUID.randomUUID().toString(),
User.Source.UNKNOWN);
+ CallContext.register(user, account);
+
+ Mockito.when(_domainDao.findById(20l)).thenReturn(domain);
+
Mockito.doNothing().when(_accountMgr).checkAccess(Mockito.any(Account.class),
Mockito.any(Domain.class));
+ Mockito.when(_domainDao.update(Mockito.eq(20l),
Mockito.any(DomainVO.class))).thenReturn(true);
+ Mockito.when(_accountDao.search(Mockito.any(SearchCriteria.class),
(Filter)org.mockito.Matchers.isNull())).thenReturn(new ArrayList<AccountVO>());
+
Mockito.when(_networkDomainDao.listNetworkIdsByDomain(Mockito.anyLong())).thenReturn(new
ArrayList<Long>());
+
Mockito.when(_accountDao.findCleanupsForRemovedAccounts(Mockito.anyLong())).thenReturn(new
ArrayList<AccountVO>());
+
Mockito.when(_dedicatedDao.listByDomainId(Mockito.anyLong())).thenReturn(new
ArrayList<DedicatedResourceVO>());
+ Mockito.when(_domainDao.remove(Mockito.anyLong())).thenReturn(true);
+
Mockito.when(_configMgr.releaseDomainSpecificVirtualRanges(Mockito.anyLong())).thenReturn(true);
+
Mockito.when(_diskOfferingDao.listByDomainId(Mockito.anyLong())).thenReturn(new
ArrayList<DiskOfferingVO>());
+
Mockito.when(_offeringsDao.findServiceOfferingByDomainId(Mockito.anyLong())).thenReturn(new
ArrayList<ServiceOfferingVO>());
+
+ try {
+ Assert.assertTrue(domainManager.deleteDomain(20l, false));
+ } finally {
+ CallContext.unregister();
+ }
+ }
+
+ @Test
+ public void deleteDomainCleanup() {
+ DomainVO domain = new DomainVO();
+ domain.setId(20l);
+ domain.setAccountId(30l);
+ Account account = new AccountVO("testaccount", 1L, "networkdomain",
(short)0, "uuid");
+ UserVO user = new UserVO(1, "testuser", "password", "firstname",
"lastName", "email", "timezone", UUID.randomUUID().toString(),
User.Source.UNKNOWN);
+ CallContext.register(user, account);
+
+ Mockito.when(_domainDao.findById(20l)).thenReturn(domain);
+
Mockito.doNothing().when(_accountMgr).checkAccess(Mockito.any(Account.class),
Mockito.any(Domain.class));
+ Mockito.when(_domainDao.update(Mockito.eq(20l),
Mockito.any(DomainVO.class))).thenReturn(true);
+
Mockito.when(_domainDao.createSearchCriteria()).thenReturn(Mockito.mock(SearchCriteria.class));
+ Mockito.when(_domainDao.search(Mockito.any(SearchCriteria.class),
(Filter)org.mockito.Matchers.isNull())).thenReturn(new ArrayList<DomainVO>());
+
Mockito.when(_accountDao.createSearchCriteria()).thenReturn(Mockito.mock(SearchCriteria.class));
+ Mockito.when(_accountDao.search(Mockito.any(SearchCriteria.class),
(Filter)org.mockito.Matchers.isNull())).thenReturn(new ArrayList<AccountVO>());
+
Mockito.when(_networkDomainDao.listNetworkIdsByDomain(Mockito.anyLong())).thenReturn(new
ArrayList<Long>());
+
Mockito.when(_accountDao.findCleanupsForRemovedAccounts(Mockito.anyLong())).thenReturn(new
ArrayList<AccountVO>());
+
Mockito.when(_dedicatedDao.listByDomainId(Mockito.anyLong())).thenReturn(new
ArrayList<DedicatedResourceVO>());
+ Mockito.when(_domainDao.remove(Mockito.anyLong())).thenReturn(true);
+
Mockito.when(_resourceCountDao.removeEntriesByOwner(Mockito.anyLong(),
Mockito.eq(ResourceOwnerType.Domain))).thenReturn(1l);
+
Mockito.when(_resourceLimitDao.removeEntriesByOwner(Mockito.anyLong(),
Mockito.eq(ResourceOwnerType.Domain))).thenReturn(1l);
+
Mockito.when(_configMgr.releaseDomainSpecificVirtualRanges(Mockito.anyLong())).thenReturn(true);
+
Mockito.when(_diskOfferingDao.listByDomainId(Mockito.anyLong())).thenReturn(new
ArrayList<DiskOfferingVO>());
+
Mockito.when(_offeringsDao.findServiceOfferingByDomainId(Mockito.anyLong())).thenReturn(new
ArrayList<ServiceOfferingVO>());
+
+ try {
+ Assert.assertTrue(domainManager.deleteDomain(20l, true));
+ } finally {
+ CallContext.unregister();
+ }
+ }
}
--
To stop receiving notification emails like this one, please contact
"commits@cloudstack.apache.org" <commits@cloudstack.apache.org>.
