Java tutorial
/** * Abiquo community edition * cloud management application for hybrid clouds * Copyright (C) 2008-2010 - Abiquo Holdings S.L. * * This application 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 under * version 3 of the License * * This software 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 v.3 for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ package com.abiquo.api.services; import static com.abiquo.api.util.URIResolver.buildPath; import java.util.Collection; import java.util.Collections; import java.util.List; import javax.persistence.EntityManager; import javax.ws.rs.core.MultivaluedMap; import org.apache.commons.lang.StringUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.security.AccessDeniedException; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import com.abiquo.api.exceptions.APIError; import com.abiquo.api.resources.DatacenterResource; import com.abiquo.api.resources.DatacentersResource; import com.abiquo.api.resources.config.PricingTemplateResource; import com.abiquo.api.resources.config.PricingTemplatesResource; import com.abiquo.api.services.appslibrary.CategoryService; import com.abiquo.api.spring.security.SecurityService; import com.abiquo.api.util.URIResolver; import com.abiquo.model.enumerator.Privileges; import com.abiquo.model.rest.RESTLink; import com.abiquo.model.transport.error.CommonError; import com.abiquo.server.core.appslibrary.Category; import com.abiquo.server.core.cloud.VirtualDatacenter; import com.abiquo.server.core.cloud.VirtualDatacenterRep; import com.abiquo.server.core.cloud.VirtualMachineRep; import com.abiquo.server.core.common.Limit; import com.abiquo.server.core.enterprise.DatacenterLimits; import com.abiquo.server.core.enterprise.DatacenterLimitsDto; import com.abiquo.server.core.enterprise.Enterprise; import com.abiquo.server.core.enterprise.EnterpriseDto; import com.abiquo.server.core.enterprise.EnterpriseRep; import com.abiquo.server.core.enterprise.Privilege; import com.abiquo.server.core.enterprise.Role; import com.abiquo.server.core.enterprise.RoleLdap; import com.abiquo.server.core.enterprise.User; import com.abiquo.server.core.infrastructure.Datacenter; import com.abiquo.server.core.infrastructure.InfrastructureRep; import com.abiquo.server.core.infrastructure.Machine; import com.abiquo.server.core.infrastructure.MachineDto; import com.abiquo.server.core.infrastructure.network.VLANNetwork; import com.abiquo.server.core.pricing.PricingRep; import com.abiquo.server.core.pricing.PricingTemplate; import com.abiquo.tracer.ComponentType; import com.abiquo.tracer.EventType; import com.abiquo.tracer.SeverityType; @Service public class EnterpriseService extends DefaultApiService { @Autowired protected EnterpriseRep repo; @Autowired private VirtualDatacenterRep vdcRepo; @Autowired private InfrastructureRep infraRep; @Autowired PricingRep pricingRep; @Autowired private UserService userService; @Autowired private DatacenterService datacenterService; @Autowired private SecurityService securityService; @Autowired protected VirtualMachineRep virtualMachineRep; @Autowired private CategoryService categoryService; /** Autowired Virtual Infrastructure DAO repository. */ @Autowired protected VirtualDatacenterRep virtualDatacenterRep; public EnterpriseService() { } public EnterpriseService(final EntityManager em) { repo = new EnterpriseRep(em); vdcRepo = new VirtualDatacenterRep(em); infraRep = new InfrastructureRep(em); userService = new UserService(em); datacenterService = new DatacenterService(em); } @Transactional(readOnly = true) public Enterprise getCurrentEnterprise() { return userService.getCurrentUser().getEnterprise(); } @Transactional(readOnly = true) public Collection<Enterprise> getEnterprises(final Integer startwith, final int idPricingTempl, final boolean included, final String filterName, final Integer numResults) { User user = userService.getCurrentUser(); PricingTemplate pt = null; // id pricing -1 if (idPricingTempl != -1) { if (idPricingTempl != 0) { pt = findPricingTemplate(idPricingTempl); } } // if (user.getRole().getType() == Role.Type.ENTERPRISE_ADMIN) if (!securityService.hasPrivilege(Privileges.ENTERPRISE_ENUMERATE) && !securityService.hasPrivilege(Privileges.USERS_MANAGE_OTHER_ENTERPRISES) && !securityService.hasPrivilege(Privileges.ENTERPRISE_ADMINISTER_ALL)) { if (idPricingTempl != -1) { return repo.findByPricingTemplate(startwith, pt, included, filterName, numResults, user.getEnterprise().getId()); } return Collections.singletonList(user.getEnterprise()); } if (idPricingTempl != -1) { if (idPricingTempl != 0) { pt = findPricingTemplate(idPricingTempl); } return repo.findByPricingTemplate(startwith, pt, included, filterName, numResults, null); } if (!StringUtils.isEmpty(filterName)) { return repo.findByNameAnywhere(filterName); } return repo.findAll(startwith, numResults); } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public Enterprise addEnterprise(final EnterpriseDto dto) { if (repo.existsAnyWithName(dto.getName())) { addConflictErrors(APIError.ENTERPRISE_DUPLICATED_NAME); flushErrors(); } Enterprise enterprise = new Enterprise(dto.getName(), dto.getRamSoftLimitInMb(), dto.getCpuCountSoftLimit(), dto.getHdSoftLimitInMb(), dto.getRamHardLimitInMb(), dto.getCpuCountHardLimit(), dto.getHdHardLimitInMb()); enterprise.setIsReservationRestricted(dto.getIsReservationRestricted()); enterprise.setStorageLimits(new Limit(dto.getStorageSoft(), dto.getStorageHard())); enterprise.setRepositoryLimits(new Limit(dto.getRepositorySoft(), dto.getRepositoryHard())); enterprise.setVlansLimits(new Limit(dto.getVlansSoft(), dto.getVlansHard())); enterprise.setPublicIPLimits(new Limit(dto.getPublicIpsSoft(), dto.getPublicIpsHard())); // if we are in community the Pricingtemplate id is not informed, is null // in this case we don't overwrite the old value. if (securityService.hasPrivilege(Privileges.PRICING_MANAGE)) { if (dto.searchLink(PricingTemplateResource.PRICING_TEMPLATE) != null) { int idPricing = getPricingTemplateId(dto); if (idPricing == 0) { enterprise.setPricingTemplate(null); } else { PricingTemplate pricingTemplate = findPricingTemplate(idPricing); enterprise.setPricingTemplate(pricingTemplate); } } } isValidEnterprise(enterprise); repo.insert(enterprise); tracer.log(SeverityType.INFO, ComponentType.ENTERPRISE, EventType.ENTERPRISE_CREATE, "enterprise.created", enterprise.getName()); return enterprise; } @Transactional(readOnly = true) public PricingTemplate getPricingTemplate(final Integer id) { PricingTemplate pt = pricingRep.findPricingTemplateById(id); if (pt == null) { addNotFoundErrors(APIError.NON_EXISTENT_PRICING_TEMPLATE); flushErrors(); } return pt; } @Transactional(readOnly = true) public Enterprise getEnterprise(final Integer id) { Enterprise enterprise = repo.findById(id); if (enterprise == null) { addNotFoundErrors(APIError.NON_EXISTENT_ENTERPRISE); flushErrors(); } // userService.checkEnterpriseAdminCredentials(enterprise); userService.checkCurrentEnterprise(enterprise); return enterprise; } /** * This method does not enforce same enterprise. But does check for privs. * * @param id * @return Enterprise */ @Transactional(readOnly = true) public Enterprise getAnyEnterprise(final Integer id) { Enterprise enterprise = repo.findById(id); if (enterprise == null) { addNotFoundErrors(APIError.NON_EXISTENT_ENTERPRISE); flushErrors(); } return enterprise; } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public Enterprise modifyEnterprise(final Integer enterpriseId, final EnterpriseDto dto) { Enterprise old = repo.findById(enterpriseId); if (old == null) { addNotFoundErrors(APIError.NON_EXISTENT_ENTERPRISE); flushErrors(); } Integer userEnt = userService.getCurrentUser().getEnterprise().getId(); if (!securityService.hasPrivilege(Privileges.USERS_MANAGE_OTHER_ENTERPRISES) && !userEnt.equals(dto.getId())) { throw new AccessDeniedException(""); } if (dto.getName().isEmpty()) { addValidationErrors(APIError.ENTERPRISE_EMPTY_NAME); flushErrors(); } if (repo.existsAnyOtherWithName(old, dto.getName())) { addConflictErrors(APIError.ENTERPRISE_DUPLICATED_NAME); flushErrors(); } old.setName(dto.getName()); old.setIsReservationRestricted(dto.getIsReservationRestricted()); old.setRamLimitsInMb(new Limit((long) dto.getRamSoftLimitInMb(), (long) dto.getRamHardLimitInMb())); old.setCpuCountLimits(new Limit((long) dto.getCpuCountSoftLimit(), (long) dto.getCpuCountHardLimit())); old.setHdLimitsInMb(new Limit(dto.getHdSoftLimitInMb(), dto.getHdHardLimitInMb())); old.setStorageLimits(new Limit(dto.getStorageSoft(), dto.getStorageHard())); old.setRepositoryLimits(new Limit(dto.getRepositorySoft(), dto.getRepositoryHard())); old.setVlansLimits(new Limit(dto.getVlansSoft(), dto.getVlansHard())); old.setPublicIPLimits(new Limit(dto.getPublicIpsSoft(), dto.getPublicIpsHard())); isValidEnterprise(old); isValidEnterpriseLimit(old); // if we are in community the Pricingtemplate id is not informed, is null // in this case we don't overwrite the old value. if (securityService.hasPrivilege(Privileges.PRICING_MANAGE)) { if (dto.searchLink(PricingTemplateResource.PRICING_TEMPLATE) != null) { int idPricing = getPricingTemplateId(dto); if (idPricing == 0) { old.setPricingTemplate(null); } else { PricingTemplate pricingTemplate = findPricingTemplate(idPricing); old.setPricingTemplate(pricingTemplate); tracer.log(SeverityType.INFO, ComponentType.ENTERPRISE, EventType.PRICING_TEMPLATE_ASSIGNED, "pricingtemplate.assigned", pricingTemplate.getName(), old.getName()); } } } repo.update(old); tracer.log(SeverityType.INFO, ComponentType.ENTERPRISE, EventType.ENTERPRISE_MODIFY, "enterprise.modified", old.getName()); return old; } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public void removeEnterprise(final Integer id) { Enterprise enterprise = getEnterprise(id); User user = userService.getCurrentUser(); if (user.getEnterprise().equals(enterprise)) { addConflictErrors(APIError.ENTERPRISE_DELETE_OWN_ENTERPRISE); flushErrors(); } Collection<VirtualDatacenter> vdcs = vdcRepo.findByEnterprise(enterprise); if (!vdcs.isEmpty()) { addConflictErrors(APIError.ENTERPRISE_DELETE_ERROR_WITH_VDCS); flushErrors(); } // Release reserved machines List<Machine> reservedMachines = findReservedMachines(id); if (reservedMachines != null && !reservedMachines.isEmpty()) { for (Machine m : reservedMachines) { releaseMachine(m.getId(), id); } } if (!userService.enterpriseWithBlockedRoles(enterprise).isEmpty()) { String message = "Cannot delete enterprise because some users have roles with super privileges (" + userService.enterpriseWithBlockedRoles(enterprise) + "), please change their enterprise before continuing"; addConflictErrors(new CommonError(APIError.ENTERPRISE_WITH_BLOCKED_USER.getCode(), message)); flushErrors(); } // user with blocked role is checked before Collection<Role> roles = repo.findRolesByEnterpriseNotNull(enterprise, null, null, false, 0, 1000); if (roles != null) { for (Role r : roles) { Collection<User> users = repo.findUsersByRole(r); if (users != null) { for (User u : users) { repo.removeUser(u); } } deleteRole(r); } } Collection<Category> categories = categoryService.getCategories(enterprise.getId(), true); if (categories != null) { for (Category c : categories) { categoryService.removeCategory(c.getId()); } } Collection<VLANNetwork> vlans = virtualDatacenterRep.findExternalVlansByEnterprise(enterprise); if (vlans != null) { for (VLANNetwork v : vlans) { virtualDatacenterRep.deleteVLAN(v); } } removeEnterpriseProperties(enterprise); repo.delete(enterprise); tracer.log(SeverityType.INFO, ComponentType.ENTERPRISE, EventType.ENTERPRISE_DELETE, "enterprise.deleted", enterprise.getName()); } protected void deleteRole(final Role role) { repo.deleteRole(role); } @Transactional(readOnly = true) public List<Machine> findReservedMachines(final Integer enterpriseId) { return repo.findReservedMachines(getEnterprise(enterpriseId)); } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public Machine reserveMachine(final MachineDto machineDto, final Integer enterpriseId) { return reserveMachine(machineDto.getId(), enterpriseId); } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public Machine reserveMachine(final Integer machineId, final Integer enterpriseId) { Machine machine = infraRep.findMachineById(machineId); if (machine == null) { addNotFoundErrors(APIError.NON_EXISTENT_MACHINE); flushErrors(); } Enterprise enterprise = getEnterprise(enterpriseId); if (machine.getEnterprise() != null) { if (machine.getEnterprise().getId() != enterpriseId) { addConflictErrors(APIError.MACHINE_RESERVED_ENTERPRISE); flushErrors(); } else { addConflictErrors(APIError.MACHINE_ALREADY_RESERVED); flushErrors(); } } repo.reserveMachine(machine, enterprise); return machine; } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public void releaseMachine(final Integer machineId, final Integer enterpriseId) { Enterprise enterprise = getEnterprise(enterpriseId); Machine machine = repo.findReservedMachine(enterprise, machineId); if (machine == null) { addNotFoundErrors(APIError.MACHINE_NOT_RESERVED); flushErrors(); } repo.releaseMachine(machine); } @Transactional(readOnly = true) public DatacenterLimits findLimitsByEnterpriseAndIdentifier(final Integer enterpriseId, final Integer limitId) { Enterprise enterprise = getEnterprise(enterpriseId); return findLimitsByEnterpriseAndIdentifier(enterprise, limitId); } @Transactional(readOnly = true) private DatacenterLimits findLimitsByEnterpriseAndIdentifier(final Enterprise enterprise, final Integer limitId) { DatacenterLimits limit = repo.findLimitsByEnterpriseAndIdentifier(enterprise, limitId); if (limit == null) { addNotFoundErrors(APIError.LIMITS_NOT_EXIST); flushErrors(); } return limit; } @Transactional(readOnly = true) public Collection<DatacenterLimits> findLimitsByEnterprise(final Integer enterpriseId) { Enterprise enterprise = getEnterprise(enterpriseId); return repo.findLimitsByEnterprise(enterprise); } /** * Checks enterprise and datacenter exists and have a limits relation (datacenter allowed by * enterprise). */ @Transactional(readOnly = true) public DatacenterLimits findLimitsByEnterpriseAndDatacenter(final Integer enterpriseId, final Integer datacenterId) { Enterprise enterprise = getEnterprise(enterpriseId); Datacenter datacenter = datacenterService.getDatacenter(datacenterId); return repo.findLimitsByEnterpriseAndDatacenter(enterprise, datacenter); } /** * Checks enterprise and datacenter exists and have a limits relation (datacenter allowed by * enterprise). */ @Transactional(readOnly = true) public DatacenterLimits findLimitsByEnterpriseVMTShared(final Integer enterpriseId, final Integer datacenterId) { Enterprise enterprise = getAnyEnterprise(enterpriseId); Datacenter datacenter = datacenterService.getDatacenter(datacenterId); return repo.findLimitsByEnterpriseAndDatacenter(enterprise, datacenter); } @Transactional(readOnly = true) public Collection<DatacenterLimits> findLimitsByDatacenter(final Integer datacenterId) { Datacenter datacenter = datacenterService.getDatacenter(datacenterId); return repo.findLimitsByDatacenter(datacenter); } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public DatacenterLimits createDatacenterLimits(final Integer enterpriseId, final Integer datacenterId, final DatacenterLimitsDto dto) { Enterprise enterprise = getEnterprise(enterpriseId); Datacenter datacenter = null; if (datacenterId != null) { datacenter = datacenterService.getDatacenter(datacenterId); } else { datacenter = getDatacenter(dto); } if (repo.findLimitsByEnterpriseAndDatacenter(enterprise, datacenter) != null) { addConflictErrors(APIError.LIMITS_DUPLICATED); flushErrors(); } DatacenterLimits limit = new DatacenterLimits(enterprise, datacenter, dto.getRamSoftLimitInMb(), dto.getCpuCountSoftLimit(), dto.getHdSoftLimitInMb(), dto.getRamHardLimitInMb(), dto.getCpuCountHardLimit(), dto.getHdHardLimitInMb(), dto.getStorageSoft(), dto.getStorageHard(), dto.getPublicIpsSoft(), dto.getPublicIpsHard(), dto.getVlansSoft(), dto.getVlansHard()); if (!limit.isValid()) { addValidationErrors(limit.getValidationErrors()); flushErrors(); } isValidDatacenterLimit(limit); repo.insertLimit(limit); return limit; } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public DatacenterLimits updateDatacenterLimits(final Integer enterpriseId, final Integer limitId, final DatacenterLimitsDto dto) { Enterprise enterprise = getEnterprise(enterpriseId); DatacenterLimits old = findLimitsByEnterpriseAndIdentifier(enterprise, limitId); old.setRamLimitsInMb(new Limit((long) dto.getRamSoftLimitInMb(), (long) dto.getRamHardLimitInMb())); old.setCpuCountLimits(new Limit((long) dto.getCpuCountSoftLimit(), (long) dto.getCpuCountHardLimit())); old.setHdLimitsInMb(new Limit(dto.getHdSoftLimitInMb(), dto.getHdHardLimitInMb())); old.setRepositoryLimits(new Limit(dto.getRepositorySoftLimitsInMb(), dto.getRepositoryHardLimitsInMb())); old.setStorageLimits(new Limit(dto.getStorageSoft(), dto.getStorageHard())); old.setPublicIPLimits(new Limit(dto.getPublicIpsSoft(), dto.getPublicIpsHard())); old.setVlansLimits(new Limit(dto.getVlansSoft(), dto.getVlansHard())); if (!old.isValid()) { addValidationErrors(old.getValidationErrors()); flushErrors(); } isValidDatacenterLimit(old); repo.updateLimit(old); return old; } protected void isValidDatacenterLimit(final DatacenterLimits dcLimits) { // community dummy impl (no limit check) } @Transactional(readOnly = false, propagation = Propagation.REQUIRED) public void deleteDatacenterLimits(final Integer enterpriseId, final Integer limitId) { Enterprise enterprise = getEnterprise(enterpriseId); DatacenterLimits limit = findLimitsByEnterpriseAndIdentifier(enterprise, limitId); Collection<VirtualDatacenter> vdcs = vdcRepo.findByEnterpriseAndDatacenter(enterprise, limit.getDatacenter(), 0, 0, "", VirtualDatacenter.OrderByEnum.NAME, true); if (vdcs != null && !vdcs.isEmpty()) { addConflictErrors(APIError.DATACENTER_LIMIT_DELETE_VDCS); flushErrors(); } repo.deleteLimit(limit); } @Transactional(readOnly = true) private Datacenter getDatacenter(final DatacenterLimitsDto dto) { RESTLink datacenterLink = dto.searchLink("datacenter"); if (datacenterLink == null) { addNotFoundErrors(APIError.NON_EXISTENT_DATACENTER); flushErrors(); } String buildPath = buildPath(DatacentersResource.DATACENTERS_PATH, DatacenterResource.DATACENTER_PARAM); MultivaluedMap<String, String> values = URIResolver.resolveFromURI(buildPath, datacenterLink.getHref()); if (values.isEmpty()) { addNotFoundErrors(APIError.NON_EXISTENT_DATACENTER); flushErrors(); } Integer datacenterId = Integer.valueOf(values.getFirst(DatacenterResource.DATACENTER)); return datacenterService.getDatacenter(datacenterId); } protected void isValidEnterprise(final Enterprise enterprise) { if (!enterprise.isValid()) { addValidationErrors(enterprise.getValidationErrors()); } flushErrors(); } @Transactional(readOnly = true) public Collection<Privilege> findAllPrivileges() { return repo.findAllPrivileges(); } @Transactional(readOnly = true) public Privilege getPrivilege(final Integer id) { Privilege privilege = repo.findPrivilegeById(id); if (privilege == null) { addNotFoundErrors(APIError.NON_EXISTENT_PRIVILEGE); flushErrors(); } return privilege; } @Transactional(readOnly = true) public Collection<Privilege> getAllPrivileges() { return repo.findAllPrivileges(); } @Transactional(readOnly = true) public RoleLdap getRoleLdap(final String roleLdap) { List<RoleLdap> list = repo.findRoleLdapByRoleLdap(roleLdap); if (list == null || list.isEmpty()) { addNotFoundErrors(APIError.NON_EXISTENT_ROLELDAP); flushErrors(); } else if (list.size() > 1) { addConflictErrors(APIError.MULTIPLE_ENTRIES_ROLELDAP); flushErrors(); } return list.get(0); } @Transactional(readOnly = true) public RoleLdap getRoleLdapOrNull(final String roleLdap) { List<RoleLdap> list = repo.findRoleLdapByRoleLdap(roleLdap); if (list.size() > 1) { addConflictErrors(APIError.MULTIPLE_ENTRIES_ROLELDAP); flushErrors(); } return list == null || list.isEmpty() ? null : list.get(0); } @Transactional(readOnly = true) public Role findRoleById(final Integer id) { return repo.findRoleById(id); } @Transactional(readOnly = true) public List<Privilege> findPrivilegesByRole(final Role role) { return repo.findPrivilegesByRole(role); } protected void isValidEnterpriseLimit(final Enterprise old) { // community dummy impl (no limit check) } private PricingTemplate findPricingTemplate(final Integer id) { PricingTemplate pt = pricingRep.findPricingTemplateById(id); if (pt == null) { addNotFoundErrors(APIError.NON_EXISTENT_PRICING_TEMPLATE); flushErrors(); } return pt; } private Integer getPricingTemplateId(final EnterpriseDto dto) { RESTLink pt = dto.searchLink(PricingTemplateResource.PRICING_TEMPLATE); if (pt == null) { addValidationErrors(APIError.MISSING_PRICING_TEMPLATE_LINK); flushErrors(); } String buildPath = buildPath(PricingTemplatesResource.PRICING_TEMPLATES_PATH, PricingTemplateResource.PRICING_TEMPLATE_PARAM); MultivaluedMap<String, String> values = URIResolver.resolveFromURI(buildPath, pt.getHref()); if (values == null || !values.containsKey(PricingTemplateResource.PRICING_TEMPLATE)) { addNotFoundErrors(APIError.PRICING_TEMPLATE_PARAM_NOT_FOUND); flushErrors(); } Integer pricingTemplateId = Integer.valueOf(values.getFirst(PricingTemplateResource.PRICING_TEMPLATE)); return pricingTemplateId; } protected void removeEnterpriseProperties(final Enterprise enterprise) { // PREMIUM } }