public static final Logger s_logger = Logger.getLogger(AffinityGroupServiceImpl.class);

private String _name;

@Inject

AccountManager _accountMgr;

@Inject

AffinityGroupDao _affinityGroupDao;

@Inject

AffinityGroupVMMapDao _affinityGroupVMMapDao;

@Inject

AffinityGroupDomainMapDao _affinityGroupDomainMapDao;

@Inject

private UserVmDao _userVmDao;

@Inject

DomainDao _domainDao;

@Inject

DomainManager _domainMgr;

@Inject

MessageBus _messageBus;

protected List<AffinityGroupProcessor> _affinityProcessors;

public List<AffinityGroupProcessor> getAffinityGroupProcessors() {

return _affinityProcessors;

}

public void setAffinityGroupProcessors(List<AffinityGroupProcessor> affinityProcessors) {

_affinityProcessors = affinityProcessors;

}

@DB

@Override

@ActionEvent(eventType = EventTypes.EVENT_AFFINITY_GROUP_CREATE, eventDescription = "Creating Affinity Group", create = true)

public AffinityGroup createAffinityGroup(String account, Long projectId, Long domainId, String affinityGroupName, String affinityGroupType, String description) {

//validate the affinityGroupType

Map<String, AffinityGroupProcessor> typeProcessorMap = getAffinityTypeToProcessorMap();

if (typeProcessorMap != null && !typeProcessorMap.isEmpty()) {

if (!typeProcessorMap.containsKey(affinityGroupType)) {

throw new InvalidParameterValueException("Unable to create affinity group, invalid affinity group type" + affinityGroupType);

}

} else {

throw new InvalidParameterValueException("Unable to create affinity group, no Affinity Group Types configured");

}

AffinityGroupProcessor processor = typeProcessorMap.get(affinityGroupType);

if (processor.isAdminControlledGroup()) {

throw new PermissionDeniedException("Cannot create the affinity group");

}

return createAffinityGroupInternal(account, projectId, domainId, affinityGroupName, affinityGroupType, description);

}

@DB

@Override

public AffinityGroup createAffinityGroupInternal(String account, final Long projectId, final Long domainId, final String affinityGroupName, final String affinityGroupType,

final String description) {

Account caller = CallContext.current().getCallingAccount();

// validate the affinityGroupType

Map<String, AffinityGroupProcessor> typeProcessorMap = getAffinityTypeToProcessorMap();

if (typeProcessorMap != null && !typeProcessorMap.isEmpty()) {

if (!typeProcessorMap.containsKey(affinityGroupType)) {

throw new InvalidParameterValueException("Unable to create affinity group, invalid affinity group type" + affinityGroupType);

}

} else {

throw new InvalidParameterValueException("Unable to create affinity group, no Affinity Group Types configured");

}

final AffinityGroupProcessor processor = typeProcessorMap.get(affinityGroupType);

if (processor.isAdminControlledGroup() && !_accountMgr.isRootAdmin(caller.getId())) {

throw new PermissionDeniedException("Cannot create the affinity group");

}

ControlledEntity.ACLType aclType = null;

Account owner = null;

boolean domainLevel = false;

if (account != null && domainId != null) {

owner = _accountMgr.finalizeOwner(caller, account, domainId, null);

aclType = ControlledEntity.ACLType.Account;

} else if (domainId != null && account == null) {

if (!_accountMgr.isRootAdmin(caller.getId())) {

// non root admin need to pass both account and domain

throw new InvalidParameterValueException("Unable to create affinity group, account name must be passed with the domainId");

} else if (!processor.canBeSharedDomainWide()) {

// cannot be domain level

throw new InvalidParameterValueException("Unable to create affinity group, account name is needed");

}

DomainVO domain = _domainDao.findById(domainId);

if (domain == null) {

throw new InvalidParameterValueException("Unable to find domain by specified id");

}

_accountMgr.checkAccess(caller, domain);

// domain level group, owner is SYSTEM.

owner = _accountMgr.getAccount(Account.ACCOUNT_ID_SYSTEM);

aclType = ControlledEntity.ACLType.Domain;

domainLevel = true;

} else {

owner = caller;

aclType = ControlledEntity.ACLType.Account;

}

if (_affinityGroupDao.isNameInUse(owner.getAccountId(), owner.getDomainId(), affinityGroupName)) {

throw new InvalidParameterValueException("Unable to create affinity group, a group with name " + affinityGroupName + " already exists.");

}

if (domainLevel && _affinityGroupDao.findDomainLevelGroupByName(domainId, affinityGroupName) != null) {

throw new InvalidParameterValueException("Unable to create affinity group, a group with name " + affinityGroupName + " already exists under the domain.");

}

final Account ownerFinal = owner;

final ControlledEntity.ACLType aclTypeFinal = aclType;

AffinityGroupVO group = Transaction.execute(new TransactionCallback<AffinityGroupVO>() {

@Override

public AffinityGroupVO doInTransaction(TransactionStatus status) {

AffinityGroupVO group =

new AffinityGroupVO(affinityGroupName, affinityGroupType, description, ownerFinal.getDomainId(), ownerFinal.getId(), aclTypeFinal);

_affinityGroupDao.persist(group);

if (domainId != null && aclTypeFinal == ACLType.Domain) {

boolean subDomainAccess = false;

subDomainAccess = processor.subDomainAccess();

AffinityGroupDomainMapVO domainMap = new AffinityGroupDomainMapVO(group.getId(), domainId,

subDomainAccess);

_affinityGroupDomainMapDao.persist(domainMap);

//send event for storing the domain wide resource access

Map<String, Object> params = new HashMap<String, Object>();

params.put(ApiConstants.ENTITY_TYPE, AffinityGroup.class);

params.put(ApiConstants.ENTITY_ID, group.getId());

params.put(ApiConstants.DOMAIN_ID, domainId);

params.put(ApiConstants.SUBDOMAIN_ACCESS, subDomainAccess);

_messageBus.publish(_name, EntityManager.MESSAGE_ADD_DOMAIN_WIDE_ENTITY_EVENT, PublishScope.LOCAL,

params);

}

return group;

}

});

if (s_logger.isDebugEnabled()) {

s_logger.debug("Created affinity group =" + affinityGroupName);

}

return group;

}

@DB

@ActionEvent(eventType = EventTypes.EVENT_AFFINITY_GROUP_DELETE, eventDescription = "Deleting affinity group")

public boolean deleteAffinityGroup(Long affinityGroupId, String account, Long projectId, Long domainId, String affinityGroupName) {

Account caller = CallContext.current().getCallingAccount();

Long accountId = _accountMgr.finalyzeAccountId(account, domainId, projectId, true);

AffinityGroupVO group = null;

if (affinityGroupId != null) {

group = _affinityGroupDao.findById(affinityGroupId);

if (group == null) {

throw new InvalidParameterValueException("Unable to find affinity group: " + affinityGroupId + "; failed to delete group.");

}

} else if (affinityGroupName != null) {

group = _affinityGroupDao.findByAccountAndName(accountId, affinityGroupName);

if (group == null) {

throw new InvalidParameterValueException("Unable to find affinity group: " + affinityGroupName + "; failed to delete group.");

}

} else {

throw new InvalidParameterValueException("Either the affinity group Id or group name must be specified to delete the group");

}

if (affinityGroupId == null) {

affinityGroupId = group.getId();

}

// check permissions

_accountMgr.checkAccess(caller, AccessType.OperateEntry, true, group);

final Long affinityGroupIdFinal = affinityGroupId;

Transaction.execute(new TransactionCallbackNoReturn() {

@Override

public void doInTransactionWithoutResult(TransactionStatus status) {

AffinityGroupVO group = _affinityGroupDao.lockRow(affinityGroupIdFinal, true);

if (group == null) {

throw new InvalidParameterValueException("Unable to find affinity group by id " + affinityGroupIdFinal);

}

List<AffinityGroupVMMapVO> affinityGroupVmMap = _affinityGroupVMMapDao.listByAffinityGroup(affinityGroupIdFinal);

if (!affinityGroupVmMap.isEmpty()) {

SearchBuilder<AffinityGroupVMMapVO> listByAffinityGroup = _affinityGroupVMMapDao.createSearchBuilder();

listByAffinityGroup.and("affinityGroupId", listByAffinityGroup.entity().getAffinityGroupId(), SearchCriteria.Op.EQ);

listByAffinityGroup.done();

SearchCriteria<AffinityGroupVMMapVO> sc = listByAffinityGroup.create();

sc.setParameters("affinityGroupId", affinityGroupIdFinal);

_affinityGroupVMMapDao.lockRows(sc, null, true);

_affinityGroupVMMapDao.remove(sc);

}

// call processor to handle the group delete

AffinityGroupProcessor processor = getAffinityGroupProcessorForType(group.getType());

if (processor != null) {

processor.handleDeleteGroup(group);

}

if(_affinityGroupDao.expunge(affinityGroupIdFinal)){

AffinityGroupDomainMapVO groupDomain = _affinityGroupDomainMapDao

.findByAffinityGroup(affinityGroupIdFinal);

if (groupDomain != null) {

_affinityGroupDomainMapDao.remove(groupDomain.getId());

}

}

}

});

// remove its related ACL permission

Pair<Class<?>, Long> params = new Pair<Class<?>, Long>(AffinityGroup.class, affinityGroupIdFinal);

_messageBus.publish(_name, EntityManager.MESSAGE_REMOVE_ENTITY_EVENT, PublishScope.LOCAL, params);

if (s_logger.isDebugEnabled()) {

s_logger.debug("Deleted affinity group id=" + affinityGroupId);

}

return true;

}

@Override

public List<String> listAffinityGroupTypes() {

List<String> types = new ArrayList<String>();

for (AffinityGroupProcessor processor : _affinityProcessors) {

if (processor.isAdminControlledGroup()) {

continue; // we dont list the type if this group can be

// created only as an admin/system operation.

}

types.add(processor.getType());

}

return types;

}

protected Map<String, AffinityGroupProcessor> getAffinityTypeToProcessorMap() {

Map<String, AffinityGroupProcessor> typeProcessorMap = new HashMap<String, AffinityGroupProcessor>();

for (AffinityGroupProcessor processor : _affinityProcessors) {

typeProcessorMap.put(processor.getType(), processor);

}

return typeProcessorMap;

}

@Override

public boolean isAdminControlledGroup(AffinityGroup group) {

if (group != null) {

String affinityGroupType = group.getType();

Map<String, AffinityGroupProcessor> typeProcessorMap = getAffinityTypeToProcessorMap();

if (typeProcessorMap != null && !typeProcessorMap.isEmpty()) {

AffinityGroupProcessor processor = typeProcessorMap.get(affinityGroupType);

if (processor != null) {

return processor.isAdminControlledGroup();

}

}

}

return false;

}

@Override

public boolean configure(final String name, final Map<String, Object> params) throws ConfigurationException {

_name = name;

VirtualMachine.State.getStateMachine().registerListener(this);

return true;

}

@Override

public boolean start() {

return true;

}

@Override

public boolean stop() {

return true;

}

@Override

public String getName() {

return _name;

}

@Override

public AffinityGroup getAffinityGroup(Long groupId) {

return _affinityGroupDao.findById(groupId);

}

@Override

public boolean preStateTransitionEvent(State oldState, Event event, State newState, VirtualMachine vo, boolean status, Object opaque) {

return true;

}

@Override

public boolean postStateTransitionEvent(StateMachine2.Transition<State, Event> transition, VirtualMachine vo, boolean status, Object opaque) {

if (!status) {

return false;

}

State newState = transition.getToState();

if ((newState == State.Expunging) || (newState == State.Error)) {

// cleanup all affinity groups associations of the Expunged VM

SearchCriteria<AffinityGroupVMMapVO> sc = _affinityGroupVMMapDao.createSearchCriteria();

sc.addAnd("instanceId", SearchCriteria.Op.EQ, vo.getId());

_affinityGroupVMMapDao.expunge(sc);

}

return true;

}

@Override

public UserVm updateVMAffinityGroups(Long vmId, List<Long> affinityGroupIds) {

// Verify input parameters

UserVmVO vmInstance = _userVmDao.findById(vmId);

if (vmInstance == null) {

throw new InvalidParameterValueException("unable to find a virtual machine with id " + vmId);

}

// Check that the VM is stopped

if (!vmInstance.getState().equals(State.Stopped)) {

s_logger.warn("Unable to update affinity groups of the virtual machine " + vmInstance.toString() + " in state " + vmInstance.getState());

throw new InvalidParameterValueException("Unable update affinity groups of the virtual machine " + vmInstance.toString() + " " + "in state " +

vmInstance.getState() + "; make sure the virtual machine is stopped and not in an error state before updating.");

}

Account caller = CallContext.current().getCallingAccount();

Account owner = _accountMgr.getAccount(vmInstance.getAccountId());

// check that the affinity groups exist

for (Long affinityGroupId : affinityGroupIds) {

AffinityGroupVO ag = _affinityGroupDao.findById(affinityGroupId);

if (ag == null) {

throw new InvalidParameterValueException("Unable to find affinity group by id " + affinityGroupId);

} else {

// verify permissions

_accountMgr.checkAccess(caller, null, true, owner, ag);

// Root admin has access to both VM and AG by default, but make sure the

// owner of these entities is same

if (caller.getId() == Account.ACCOUNT_ID_SYSTEM || _accountMgr.isRootAdmin(caller.getId())) {

if (ag.getAccountId() != owner.getAccountId()) {

throw new PermissionDeniedException("Affinity Group " + ag + " does not belong to the VM's account");

}

}

}

}

_affinityGroupVMMapDao.updateMap(vmId, affinityGroupIds);

if (s_logger.isDebugEnabled()) {

s_logger.debug("Updated VM :" + vmId + " affinity groups to =" + affinityGroupIds);

}

// APIResponseHelper will pull out the updated affinitygroups.

return vmInstance;

}

@Override

public boolean isAffinityGroupProcessorAvailable(String affinityGroupType) {

for (AffinityGroupProcessor processor : _affinityProcessors) {

if (affinityGroupType != null && affinityGroupType.equals(processor.getType())) {

return true;

}

}

return false;

}

private AffinityGroupProcessor getAffinityGroupProcessorForType(String affinityGroupType) {

for (AffinityGroupProcessor processor : _affinityProcessors) {

if (affinityGroupType != null && affinityGroupType.equals(processor.getType())) {

return processor;

}

}

return null;

}

@Override

public boolean isAffinityGroupAvailableInDomain(long affinityGroupId, long domainId) {

Long groupDomainId = null;

AffinityGroupDomainMapVO domainMap = _affinityGroupDomainMapDao.findByAffinityGroup(affinityGroupId);

if (domainMap == null) {

return false;

} else {

groupDomainId = domainMap.getDomainId();

}

if (domainId == groupDomainId.longValue()) {

return true;

}

if (domainMap.subdomainAccess) {

Set<Long> parentDomains = _domainMgr.getDomainParentIds(domainId);

if (parentDomains.contains(groupDomainId)) {

return true;

}

}

return false;

}