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.server.core.infrastructure; import java.net.URISyntaxException; import java.util.Collection; import java.util.HashSet; import java.util.List; import java.util.Set; import javax.persistence.EntityManager; import org.apache.commons.lang.StringUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository; import com.abiquo.model.enumerator.HypervisorType; import com.abiquo.model.enumerator.NetworkType; import com.abiquo.model.enumerator.RemoteServiceType; import com.abiquo.server.core.cloud.Hypervisor; import com.abiquo.server.core.cloud.HypervisorDAO; import com.abiquo.server.core.cloud.VirtualMachine; import com.abiquo.server.core.cloud.VirtualMachineDAO; import com.abiquo.server.core.cloud.VirtualMachineState; import com.abiquo.server.core.common.DefaultRepBase; import com.abiquo.server.core.enterprise.DatacenterLimits; import com.abiquo.server.core.enterprise.DatacenterLimitsDAO; import com.abiquo.server.core.enterprise.Enterprise; import com.abiquo.server.core.infrastructure.network.DhcpOption; import com.abiquo.server.core.infrastructure.network.DhcpOptionDAO; import com.abiquo.server.core.infrastructure.network.IpPoolManagement; import com.abiquo.server.core.infrastructure.network.IpPoolManagementDAO; import com.abiquo.server.core.infrastructure.network.Network; import com.abiquo.server.core.infrastructure.network.NetworkDAO; import com.abiquo.server.core.infrastructure.network.VLANNetwork; import com.abiquo.server.core.infrastructure.network.VLANNetworkDAO; import com.abiquo.server.core.infrastructure.storage.StorageRep; import com.abiquo.server.core.infrastructure.storage.Tier; import com.abiquo.server.core.pricing.PricingRep; import com.abiquo.server.core.util.PagedList; @Repository public class InfrastructureRep extends DefaultRepBase { /* package: test only */static final String BUG_INSERT_NAME_MUST_BE_UNIQUE = "ASSERT- insert: datacenter name must be unique"; /* package: test only */static final String BUG_UPDATE_NAME_MUST_BE_UNIQUE = "ASSERT- update: datacenter name must be unique"; /* package: test only */static final String BUG_INSERT_RACK_NAME_MUST_BE_UNIQUE = "ASSERT- rack insert: racks on the same datacenter must have a unique name"; /* package: test only */static final String BUG_UPDATE_RACK_NAME_MUST_BE_UNIQUE = "ASSERT- rack update: racks on the same datacenter must have a unique name"; /* package: test only */static final String BUG_INSERT_MACHINE_NAME_MUST_BE_UNIQUE = "ASSERT- machine insert: machines on the same datacenter must have a unique name"; /* package: test only */static final String BUG_UPDATE_MACHINE_NAME_MUST_BE_UNIQUE = "ASSERT- machine update: machines on the same datacenter must have a unique name"; @Autowired private DatacenterDAO dao; @Autowired private RackDAO rackDao; @Autowired private UcsRackDAO ucsRackDao; @Autowired private MachineDAO machineDao; @Autowired private HypervisorDAO hypervisorDao; @Autowired private DatastoreDAO datastoreDao; @Autowired private RemoteServiceDAO remoteServiceDao; @Autowired private NetworkDAO networkDao; @Autowired private VLANNetworkDAO vlanDao; @Autowired private IpPoolManagementDAO ipPoolDao; @Autowired private RepositoryDAO repositoryDao; @Autowired private VirtualMachineDAO virtualMachineDao; @Autowired private StorageRep storageRep; @Autowired private PricingRep pricingRep; @Autowired private DatacenterLimitsDAO datacenterLimitDao; @Autowired private DhcpOptionDAO dhcpOptionDAO; public InfrastructureRep() { } public InfrastructureRep(final EntityManager entityManager) { assert entityManager != null; assert entityManager.isOpen(); this.entityManager = entityManager; this.dao = new DatacenterDAO(entityManager); this.rackDao = new RackDAO(entityManager); this.ucsRackDao = new UcsRackDAO(entityManager); this.machineDao = new MachineDAO(entityManager); this.hypervisorDao = new HypervisorDAO(entityManager); this.datastoreDao = new DatastoreDAO(entityManager); this.remoteServiceDao = new RemoteServiceDAO(entityManager); this.repositoryDao = new RepositoryDAO(entityManager); this.networkDao = new NetworkDAO(entityManager); this.datacenterLimitDao = new DatacenterLimitsDAO(entityManager); this.storageRep = new StorageRep(entityManager); this.vlanDao = new VLANNetworkDAO(entityManager); this.ipPoolDao = new IpPoolManagementDAO(entityManager); this.dhcpOptionDAO = new DhcpOptionDAO(entityManager); this.virtualMachineDao = new VirtualMachineDAO(entityManager); } public Datacenter findById(final Integer id) { assert id != null; return this.dao.findById(id); } public Collection<Datacenter> findAll() { return this.dao.findAll(); } public void insert(final Datacenter datacenter) { assert datacenter != null; assert !this.dao.isManaged(datacenter); assert !existsAnyDatacenterWithName(datacenter.getName()) : BUG_INSERT_NAME_MUST_BE_UNIQUE; this.dao.persist(datacenter); this.dao.flush(); } /* * public boolean hasVirtualMachines(Datacenter datacenter) { assert datacenter != null; assert * this.dao.isManaged(datacenter); List<Machine> machines = findMachines(datacenter); if( * machines.isEmpty()) return false; for( Machine machine : machines ) { } return * this.virtualMachineDao.haveVirtualMachines(machines); } */ public void delete(final Datacenter datacenter) { assert datacenter != null; assert this.dao.isManaged(datacenter); // assert !hasVirtualMachines(datacenter); this.dao.remove(datacenter); this.dao.flush(); } public void update(final Datacenter datacenter) { assert datacenter != null; assert this.dao.isManaged(datacenter); assert !existsAnyOtherWithName(datacenter, datacenter.getName()) : BUG_UPDATE_NAME_MUST_BE_UNIQUE; this.dao.flush(); } public boolean existsAnyDatacenterWithName(final String name) { assert !StringUtils.isEmpty(name); return this.dao.existsAnyWithName(name); } public boolean existsAnyOtherWithName(final Datacenter datacenter, final String name) { assert datacenter != null; assert this.dao.isManaged(datacenter); assert !StringUtils.isEmpty(name); return this.dao.existsAnyOtherWithName(datacenter, name); } public List<Rack> findRacks(final Datacenter datacenter) { return findRacks(datacenter, null); } public List<Rack> findRacks(final Datacenter datacenter, final String filter) { assert datacenter != null; assert this.dao.isManaged(datacenter); return this.rackDao.findRacks(datacenter, filter); } public List<Machine> findMachines(final Datacenter datacenter) { return this.machineDao.findMachines(datacenter); } public List<Machine> findRackMachines(final Rack rack) { return findRackMachines(rack, null); } public List<Machine> findRackMachines(final Rack rack, final String filter) { assert rack != null; assert this.rackDao.isManaged(rack); return this.machineDao.findRackMachines(rack, filter); } public Set<HypervisorType> findHypervisors(final Datacenter datacenter) { Set<HypervisorType> types = new HashSet<HypervisorType>(); for (Machine machine : findMachines(datacenter)) { if (machine.getHypervisor() != null) { types.add(machine.getHypervisor().getType()); } } return types; } public Collection<HypervisorType> findHypervisorsType(final Datacenter datacenter) { return hypervisorDao.findTypesfromDatacenter(datacenter.getId()); } public List<Enterprise> findEnterprisesByDataCenter(final Datacenter datacenter, final Boolean network, final Integer firstElem, final Integer numElem) { PagedList<Enterprise> enterprises = new PagedList<Enterprise>(); enterprises = (PagedList<Enterprise>) this.dao.findEnterprisesByDatacenters(datacenter, firstElem, numElem, network); return enterprises; } public DatacenterLimits findDatacenterLimits(final Enterprise enterprise, final Datacenter datacenter) { return datacenterLimitDao.findByEnterpriseAndDatacenter(enterprise, datacenter); } public Collection<DatacenterLimits> findDatacenterLimits(final Enterprise enterprise) { return datacenterLimitDao.findByEnterprise(enterprise); } public boolean existsAnyRackWithName(final Datacenter datacenter, final String name) { assert datacenter != null; assert !StringUtils.isEmpty(name); return this.rackDao.existsAnyWithDatacenterAndName(datacenter, name); } public boolean existsAnyOtherRackWithName(final Rack rack, final String name) { assert rack != null; assert !StringUtils.isEmpty(name); return this.rackDao.existsAnyOtherWithDatacenterAndName(rack, name); } public boolean existsAnyUcsRackWithIp(final String ip) { return this.ucsRackDao.existAnyOtherWithIP(ip); } public boolean existsAnyVirtualMachineUsingNetwork(final Integer vlanId) { assert vlanId != null; return !this.ipPoolDao.findUsedIpsByPrivateVLAN(vlanId).isEmpty(); } public boolean existsAnyMachineWithName(final Datacenter datacenter, final String name) { assert datacenter != null; assert !StringUtils.isEmpty(name); return this.machineDao.existsAnyWithDatacenterAndName(datacenter, name); } public boolean existsAnyOtherMachineWithName(final Machine machine, final String name) { assert machine != null; assert !StringUtils.isEmpty(name); return this.machineDao.existsAnyOtherWithDatacenterAndName(machine, name); } public Rack findRackById(final Integer id) { assert id != null; return this.rackDao.findById(id); } public void insertUcsRack(final UcsRack UcsRack) { this.ucsRackDao.persist(UcsRack); this.ucsRackDao.flush(); } public UcsRack findUcsRackById(final Integer rackId) { return ucsRackDao.findById(rackId); } public void insertRack(final Rack rack) { assert rack != null; assert !this.rackDao.isManaged(rack); assert this.rackDao.isManaged2(rack.getDatacenter()); assert !existsAnyRackWithName(rack.getDatacenter(), rack.getName()) : BUG_INSERT_RACK_NAME_MUST_BE_UNIQUE; this.rackDao.persist(rack); this.rackDao.flush(); } public void updateRack(final Rack rack) { assert rack != null; assert this.rackDao.isManaged(rack); assert !existsAnyOtherRackWithName(rack, rack.getName()) : BUG_UPDATE_RACK_NAME_MUST_BE_UNIQUE; this.rackDao.flush(); } public void deleteRack(final Rack rack) { assert rack != null; assert this.rackDao.isManaged(rack); this.machineDao.deleteRackMachines(rack); this.machineDao.flush(); this.rackDao.remove(rack); this.rackDao.flush(); } public Machine findMachineById(final Integer id) { assert id != null; return this.machineDao.findById(id); } public Machine findMachineByIds(final Integer datacenterId, final Integer rackId, final Integer machineId) { return this.machineDao.findByIds(datacenterId, rackId, machineId); } public Machine findMachineByIp(final Integer datacenterId, final String ip) { Datacenter datacenter = findById(datacenterId); return this.machineDao.findByIp(datacenter, ip); } public void insertMachine(final Machine machine) { assert machine != null; assert !this.machineDao.isManaged(machine); assert !existsAnyMachineWithName(machine.getDatacenter(), machine.getName()) : BUG_INSERT_MACHINE_NAME_MUST_BE_UNIQUE; this.machineDao.persist(machine); this.machineDao.flush(); } public void updateMachine(final Machine machine) { assert machine != null; assert this.machineDao.isManaged(machine); assert !existsAnyOtherMachineWithName(machine, machine.getName()) : BUG_UPDATE_MACHINE_NAME_MUST_BE_UNIQUE; this.machineDao.flush(); } public void deleteMachine(final Machine machine) { assert machine != null; assert this.machineDao.isManaged(machine); this.machineDao.remove(machine); this.machineDao.flush(); } public void insertTier(final Tier tier) { storageRep.insertTier(tier); } public void insertHypervisor(final Hypervisor hypervisor) { assert hypervisor != null; assert hypervisor.getMachine() != null; assert hypervisor.getMachine().getDatacenter() != null; assert !hypervisorDao.isManaged(hypervisor); assert !existAnyHypervisorWithIpServiceInDatacenter(hypervisor.getIp(), hypervisor.getMachine().getDatacenter().getId()); assert !existAnyHypervisorWithIpServiceInDatacenter(hypervisor.getIpService(), hypervisor.getMachine().getDatacenter().getId()); hypervisorDao.persist(hypervisor); hypervisorDao.flush(); // Machine machine = hypervisor.getMachine(); // // machine.setHypervisor(hypervisor); // updateMachine(machine); } // public boolean existAnyHypervisorWithIp(final String ip) // { // assert !StringUtils.isEmpty(ip); // // return hypervisorDao.existsAnyWithIp(ip); // } // // public boolean existAnyHypervisorWithIpService(final String ipService) // { // assert !StringUtils.isEmpty(ipService); // // return hypervisorDao.existsAnyWithIpService(ipService); // } public List<Datastore> findMachineDatastores(final Machine machine) { assert machine != null; return datastoreDao.findMachineDatastores(machine); } public Datastore findDatastoreById(final Integer id) { assert id != null; return datastoreDao.findById(id); } public Datastore findDatastoreByUuidAndMachine(final String uuid, final Machine machine) { return datastoreDao.findDatastore(uuid, machine); } public void insertDatastore(final Datastore datastore) { assert datastore != null; assert !datastoreDao.isManaged(datastore); assert !existAnyDatastoreWithName(datastore.getName()) : "ASSERT - datastore duplicated name"; assert !existAnyDatastoreWithDirectory( datastore.getDirectory()) : "ASSERT - datastore duplicated directory"; datastoreDao.persist(datastore); datastoreDao.flush(); } public void updateDatastore(final Datastore datastore) { assert datastore != null; assert datastoreDao.isManaged(datastore); assert !existAnyOtherDatastoreWithName(datastore, datastore.getName()) : "ASSERT - datastore duplicated name"; assert !existAnyOtherDatastoreWithDirectory(datastore, datastore.getDirectory()) : "ASSERT - datastore duplicated directory"; datastoreDao.flush(); } public void deleteDatastore(final Datastore datastore) { assert datastore != null; assert this.datastoreDao.isManaged(datastore); this.datastoreDao.remove(datastore); this.datastoreDao.flush(); } public List<Datastore> findShares(final Datastore datastore) { return this.datastoreDao.findShares(datastore); } public boolean existAnyDatastoreWithName(final String name) { assert !StringUtils.isEmpty(name); return datastoreDao.existsAnyWithName(name); } public boolean existAnyOtherDatastoreWithName(final Datastore datastore, final String name) { assert !StringUtils.isEmpty(name); return datastoreDao.existsAnyOtherWithName(datastore, name); } public boolean existAnyDatastoreWithDirectory(final String directory) { assert !StringUtils.isEmpty(directory); return datastoreDao.existsAnyWithDirectory(directory); } public boolean existAnyOtherDatastoreWithDirectory(final Datastore datastore, final String directory) { assert !StringUtils.isEmpty(directory); return datastoreDao.existsAnyOtherWithDirectory(datastore, directory); } public void insertRemoteService(final RemoteService remoteService) { this.remoteServiceDao.persist(remoteService); this.remoteServiceDao.flush(); } public void insertNetwork(final Network network) { this.networkDao.persist(network); this.networkDao.flush(); } public void updateRemoteService(final RemoteService remoteService) { remoteServiceDao.flush(); } public void deleteRemoteService(final RemoteService remoteService) { assert remoteService != null; assert remoteServiceDao.isManaged(remoteService); this.remoteServiceDao.remove(remoteService); this.remoteServiceDao.flush(); } public boolean existAnyRemoteServiceWithUri(final String uri) throws URISyntaxException { return remoteServiceDao.existRemoteServiceUri(uri); } public List<RemoteService> findRemoteServicesByDatacenter(final Datacenter datacenter) { return remoteServiceDao.findByDatacenter(datacenter); } public List<RemoteService> findAllRemoteServices() { return remoteServiceDao.findAll(); } public RemoteService findRemoteServiceById(final int id) { return remoteServiceDao.findById(id); } public List<RemoteService> findRemoteServiceWithTypeInDatacenter(final Datacenter datacenter, final RemoteServiceType type) { return remoteServiceDao.findByDatacenterAndType(datacenter, type); } public boolean existAnyRemoteServiceWithTypeInDatacenter(final Datacenter datacenter, final RemoteServiceType type) { return !findRemoteServiceWithTypeInDatacenter(datacenter, type).isEmpty(); } public List<Machine> findCandidateMachines(final Integer idRack, final Integer idVirtualDatacenter, final Long hdRequiredOnDatastore, final Enterprise enterprise) { return machineDao.findCandidateMachines(idRack, idVirtualDatacenter, hdRequiredOnDatastore, enterprise); } public List<Machine> findCandidateMachines(final Integer idRack, final Integer idVirtualDatacenter, final Enterprise enterprise, final String datastoreUuid, final Integer originalHypervisorId) { return machineDao.findCandidateMachines(idRack, idVirtualDatacenter, enterprise, datastoreUuid, originalHypervisorId); } public List<Integer> getRackIdByMinVLANCount(final int idDatacenter) { return rackDao.getRackIdByMinVLANCount(idDatacenter); } // Populate requireds public Datacenter findByName(final String name) { return dao.findUniqueByProperty(Datacenter.NAME_PROPERTY, name); } public Rack findRackByName(final String name) { return rackDao.findUniqueByProperty(Rack.NAME_PROPERTY, name); } public Machine findMachineByName(final String name) { return machineDao.findUniqueByProperty(Machine.NAME_PROPERTY, name); } public Long getNumberOfDeployedVlanNetworksByRack(final Integer rackId) { return rackDao.getNumberOfDeployedVlanNetworks(rackId); } public boolean isRepositoryBeingUsed(final Datacenter datacenter) { return repositoryDao.isBeingUsed(datacenter); } public void updateRepositoryLocation(final Datacenter datacenter, final String url) { repositoryDao.updateRepositoryLocation(datacenter, url); } public void deleteRepository(final Datacenter datacenter) { repositoryDao.removeByDatacenter(datacenter); } public boolean existRepositoryInOtherDatacenter(final Datacenter datacenter, final String repositoryLocation) { return repositoryDao.existRepositoryInOtherDatacenter(datacenter, repositoryLocation); } public boolean existRepositoryInSameDatacenter(final Datacenter datacenter, final String repositoryLocation) { return repositoryDao.existRepositoryInSameDatacenter(datacenter, repositoryLocation); } public void createRepository(final Datacenter datacenter, final String repositoryLocation) { com.abiquo.server.core.infrastructure.Repository repo = new com.abiquo.server.core.infrastructure.Repository( datacenter, repositoryLocation); repositoryDao.persist(repo); } public com.abiquo.server.core.infrastructure.Repository findRepositoryByDatacenter( final Datacenter datacenter) { return repositoryDao.findByDatacenter(datacenter); } public com.abiquo.server.core.infrastructure.Repository findRepositoryByLocation(final String location) { return repositoryDao.findByRepositoryLocation(location); } public boolean existDeployedVirtualMachines(final Datacenter datacenter) { assert datacenter != null; List<VirtualMachine> vmachinesInDC = virtualMachineDao.findVirtualMachinesByDatacenter(datacenter.getId()); for (Object element : vmachinesInDC) { VirtualMachine virtualMachine = (VirtualMachine) element; // We can ignore import VMs if (virtualMachine.isManaged() && !(virtualMachine.getState().equals(VirtualMachineState.NOT_ALLOCATED) || virtualMachine.getState().equals(VirtualMachineState.UNKNOWN))) { return true; } } return false; } public Rack findRackByIds(final Integer datacenterId, final Integer rackId) { return rackDao.findByIds(datacenterId, rackId); } public List<Rack> findRacksWithHAEnabled(final Datacenter dc) { return rackDao.findRacksWithHAEnabled(dc); } public List<Machine> findRackEnabledForHAMachines(final Rack rack) { return machineDao.findRackEnabledForHAMachines(rack); } public List<Machine> findMachinesWithHAInProgress() { return machineDao.findMachinesWithHAInProgress(); } /** * Return all {@links UcsRack} associated to a * * @param datacenterId id. * @return List<UcsRack> with all {@links UcsRack} associated to the given {@link Datacenter}. */ public List<UcsRack> findAllUcsRacksByDatacenter(final Datacenter datacenter) { return findAllUcsRacksByDatacenter(datacenter, null); } public List<UcsRack> findAllUcsRacksByDatacenter(final Datacenter datacenter, final String filter) { return this.ucsRackDao.findAllUcsRacksByDatacenter(datacenter, filter); } /** * Return all not managed {@link Rack} associated to a * * @param datacenterId id. * @return List<UcsRack> with all {@links UcsRack} associated to the given {@link Datacenter}. */ public List<Rack> findAllNotManagedRacksByDatacenter(final Integer datacenterId) { return findAllNotManagedRacksByDatacenter(datacenterId, null); } public List<Rack> findAllNotManagedRacksByDatacenter(final Integer datacenterId, final String filter) { return this.rackDao.findAllNotManagedRacksByDatacenter(datacenterId, filter); } public boolean existAnyHypervisorWithIpInDatacenter(final String ip, final Integer datacenterId) { return hypervisorDao.existsAnyWithIpAndDatacenter(ip, datacenterId); } public boolean existAnyHypervisorWithIpServiceInDatacenter(final String ip, final Integer datacenterId) { return hypervisorDao.existsAnyWithIpServiceAndDatacenter(ip, datacenterId); } /** * Return all machines in a rack that are empty of VM. * * @param rackId rack. * @return Integer */ public Integer getEmptyOffMachines(final Integer rackId) { return rackDao.getEmptyOffMachines(rackId); } /** * Return all machines in a rack that are empty of VM. * * @param rackId rack. * @return Integer */ public Integer getEmptyOnMachines(final Integer rackId) { return rackDao.getEmptyOnMachines(rackId); } /** * Returns any machine that is in the rack in HALTED_FOR_SAVE. * * @param rackId rack. * @return Machine */ public List<Machine> getRandomMachinesToStartFromRack(final Integer rackId, final Integer howMany) { // TODO Auto-generated method stub return rackDao.getRandomMachinesToStartFromRack(rackId, howMany); } /** * Returns any machine that is in the rack in MANAGED. * * @param rackId rack. * @return Machine */ public List<Machine> getRandomMachinesToShutDownFromRack(final Integer rackId, final Integer howMany) { // TODO Auto-generated method stub return rackDao.getRandomMachinesToShutDownFromRack(rackId, howMany); } /** * Return all machines in a rack that are empty of VM. * * @param rackId rack. * @return Integer */ public List<Machine> getAllMachinesToShutDownFromRack(final Integer rackId) { return rackDao.getAllMachinesToShutDownFromRack(rackId); } /** * Return all the public VLANs by Datacenter. * * @param datacenter {@link Datacenter} where we search for. * @return list of found {@link VLANNetwork} */ public List<VLANNetwork> findAllPublicVlansByDatacenter(final Datacenter datacenter, final NetworkType netType) { return vlanDao.findPublicVLANNetworksByDatacenter(datacenter, netType); } /** * Return all the public VLANs by Datacenter. * * @param datacenter {@link Datacenter} where we search for. * @return list of found {@link VLANNetwork} */ public List<VLANNetwork> findAllPrivateVlansByDatacenter(final Datacenter datacenter) { return vlanDao.findPrivateVLANNetworksByDatacenter(datacenter); } /** * Return an unique VLAN inside a Datacenter. * * @param dc {@link Datacenter} where we search for. * @param vlanId identifier of the vlan. * @return the found {@link VLANNetwork}. */ public VLANNetwork findPublicVlanByDatacenter(final Datacenter dc, final Integer vlanId) { return vlanDao.findPublicVlanByDatacenter(dc, vlanId); } /** * Return the list of purchased IPs by VLAN. * * @param vlan vlan to search into. * @return the list of purchased IPs. */ public List<IpPoolManagement> findIpsPurchasedInPublicVlan(final VLANNetwork vlan) { return ipPoolDao.findPublicIpsPurchasedByVlan(vlan); } /** * Return all the IPs from a VLAN. * * @param network {@link Network} network entity that stores all the VLANs * @param vlanId identifier of the VLAN to search into. * @return all the {@link IpPoolManagement} ips. */ public List<IpPoolManagement> findIpsByNetwork(final Network network, final Integer vlanId) { return ipPoolDao.findIpsByNetwork(network, vlanId); } public void updateLimits(final DatacenterLimits dclimits) { datacenterLimitDao.flush(); } public List<VirtualMachine> getNotManagedVirtualMachines(final Hypervisor hypervisor) { return virtualMachineDao.getNotManagedVirtualMachines(hypervisor); } public VirtualMachine findVirtualMachineByHypervisor(final Hypervisor hypervisor, final Integer vmId) { return virtualMachineDao.findVirtualMachineByHypervisor(hypervisor, vmId); } public Collection<DhcpOption> findAllDhcp() { return this.dhcpOptionDAO.findAll(); } public DhcpOption findDhcpOptionById(final Integer id) { return dhcpOptionDAO.findById(id); } public void insertDhcpOption(final DhcpOption opt) { assert opt != null; assert !dhcpOptionDAO.isManaged(opt); dhcpOptionDAO.persist(opt); dhcpOptionDAO.flush(); } public void deleteAllDhcpOption(final Collection<DhcpOption> dhcpOption) { for (DhcpOption opt : dhcpOption) { this.dhcpOptionDAO.remove(opt); } this.dhcpOptionDAO.flush(); } public List<Integer> findUsedRemoteDesktopPortsInRack(final Rack rack) { return rackDao.findUsedVrdpPorts(rack); } /** * Returns the total number of cores currently used in the platform. */ public Long getTotalUsedCores() { return machineDao.getTotalUsedCores(); } /** * Returns the total number of cores currently used in the platform ignoring the given machine. */ public Long getTotalUsedCoresExceptMachine(final Machine machine) { return machineDao.getTotalUsedCoresExceptMachine(machine); } }