/**
* Copyright (C) 2008 - Abiquo Holdings S.L. All rights reserved.
*
* Please see /opt/abiquo/tomcat/webapps/legal/ on Abiquo server
* or contact contact@abiquo.com for licensing information.
*/
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.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.Rack.VlanRange;
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.NetworkInterface;
import com.abiquo.server.core.infrastructure.network.NetworkInterfaceDAO;
import com.abiquo.server.core.infrastructure.network.NetworkServiceType;
import com.abiquo.server.core.infrastructure.network.NetworkServiceTypeDAO;
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.pricing.PricingTemplate;
import com.abiquo.server.core.pricing.PricingTier;
import com.abiquo.server.core.util.PagedList;
@Repository
public class InfrastructureRep extends DefaultRepBase
{
/* 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_INSERT_NAME_MUST_BE_UNIQUE =
"ASSERT- insert: 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_MACHINE_NAME_MUST_BE_UNIQUE =
"ASSERT- machine update: machines on the same datacenter must have a unique name";
/* 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_UPDATE_RACK_NAME_MUST_BE_UNIQUE =
"ASSERT- rack update: racks on the same datacenter must have a unique name";
@Autowired
private DatacenterDAO dao;
@Autowired
private DatacenterLimitsDAO datacenterLimitDao;
@Autowired
private DatastoreDAO datastoreDao;
@Autowired
private DhcpOptionDAO dhcpOptionDAO;
@Autowired
private HypervisorDAO hypervisorDao;
@Autowired
private IpPoolManagementDAO ipPoolDao;
@Autowired
private MachineDAO machineDao;
@Autowired
private NetworkServiceTypeDAO netServiceTypeDAO;
@Autowired
private NetworkDAO networkDao;
@Autowired
private NetworkInterfaceDAO niDAO;
@Autowired
private PricingRep pricingRep;
@Autowired
private RackDAO rackDao;
@Autowired
private RemoteServiceDAO remoteServiceDao;
@Autowired
private RepositoryDAO repositoryDao;
@Autowired
private StorageRep storageRep;
@Autowired
private UcsRackDAO ucsRackDao;
@Autowired
private VirtualMachineDAO virtualMachineDao;
@Autowired
private VLANNetworkDAO vlanDao;
public InfrastructureRep()
{
}
public InfrastructureRep(final EntityManager entityManager)
{
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);
this.netServiceTypeDAO = new NetworkServiceTypeDAO(entityManager);
this.niDAO = new NetworkInterfaceDAO(entityManager);
}
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 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 deleteAllDhcpOption(final Collection<DhcpOption> dhcpOption)
{
for (DhcpOption opt : dhcpOption)
{
this.dhcpOptionDAO.remove(opt);
}
this.dhcpOptionDAO.flush();
}
public void deleteDatastore(final Datastore datastore)
{
assert datastore != null;
assert this.datastoreDao.isManaged(datastore);
this.datastoreDao.remove(datastore);
this.datastoreDao.flush();
}
public void deleteMachine(final Machine machine)
{
assert machine != null;
assert this.machineDao.isManaged(machine);
this.machineDao.remove(machine);
this.machineDao.flush();
}
public void deleteNetworkInterface(final NetworkInterface viejunaNIC)
{
niDAO.remove(viejunaNIC);
}
/*
* 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 deleteNetworkServiceType(final NetworkServiceType nst)
{
netServiceTypeDAO.remove(nst);
}
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 void deleteRemoteService(final RemoteService remoteService)
{
assert remoteService != null;
assert remoteServiceDao.isManaged(remoteService);
this.remoteServiceDao.remove(remoteService);
this.remoteServiceDao.flush();
}
public void deleteRepository(final Datacenter datacenter)
{
repositoryDao.removeByDatacenter(datacenter);
}
@Deprecated
public boolean existAnyDatastoreWithDirectory(final String directory)
{
assert !StringUtils.isEmpty(directory);
return datastoreDao.existsAnyWithDirectory(directory);
}
@Deprecated
public boolean existAnyDatastoreWithName(final String name)
{
assert !StringUtils.isEmpty(name);
return datastoreDao.existsAnyWithName(name);
}
public boolean existAnyDatastoreWithRootPath(final String rootPath, final Integer machineId)
{
assert !StringUtils.isEmpty(rootPath);
return datastoreDao.existsAnyWithRootPath(rootPath, machineId);
}
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);
}
@Deprecated
public boolean existAnyOtherDatastoreWithDirectory(final Datastore datastore,
final String directory)
{
assert !StringUtils.isEmpty(directory);
return datastoreDao.existsAnyOtherWithDirectory(datastore, directory);
}
@Deprecated
public boolean existAnyOtherDatastoreWithName(final Datastore datastore, final String name)
{
assert !StringUtils.isEmpty(name);
return datastoreDao.existsAnyOtherWithName(datastore, name);
}
public boolean existAnyOtherDatastoreWithRootPath(final Datastore datastore,
final String rootPath, final Integer machineId)
{
assert !StringUtils.isEmpty(rootPath);
return datastoreDao.existsAnyOtherWithRootPath(datastore, rootPath, machineId);
}
public boolean existAnyRemoteServiceWithTypeInDatacenter(final Datacenter datacenter,
final RemoteServiceType type)
{
return !findRemoteServiceWithTypeInDatacenter(datacenter, type).isEmpty();
}
public boolean existAnyRemoteServiceWithUri(final String uri) throws URISyntaxException
{
return remoteServiceDao.existRemoteServiceUri(uri);
}
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 CRASHED state: it means the VM is actually not deployed
if (!(virtualMachine.getState().equals("NOT_DEPLOYED") || virtualMachine.getState()
.equals("CRASHED")))
{
return true;
}
}
return false;
}
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 boolean existsAnyDatacenterWithName(final String name)
{
assert !StringUtils.isEmpty(name);
return this.dao.existsAnyWithName(name);
}
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 boolean existsAnyOtherRackWithName(final Rack rack, final String name)
{
assert rack != null;
assert !StringUtils.isEmpty(name);
return this.rackDao.existsAnyOtherWithDatacenterAndName(rack, 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 boolean existsAnyRackWithName(final Datacenter datacenter, final String name)
{
assert datacenter != null;
assert !StringUtils.isEmpty(name);
return this.rackDao.existsAnyWithDatacenterAndName(datacenter, name);
}
public boolean existsAnyUcsRackWithIpSameDatacenter(final Datacenter datacenter, final String ip)
{
return this.ucsRackDao.existAnyOtherWithIPSameDatacenter(datacenter, ip);
}
public boolean existsAnyVirtualMachineDeployedUsingNetwork(final Integer vlanId)
{
return !this.ipPoolDao.findDeployedIpsByPrivateVLAN(vlanId).isEmpty();
}
public boolean existsAnyVirtualMachineUsingNetwork(final Integer vlanId)
{
return !this.ipPoolDao.findUsedIpsByPrivateVLAN(vlanId).isEmpty();
}
public Collection<Datacenter> findAll()
{
return this.dao.findAll();
}
public Collection<Datacenter> findAllByScope(final Integer idScope, final Integer firstElem,
final Integer limit)
{
return dao.findAllByScope(idScope, firstElem, limit);
}
public Collection<DhcpOption> findAllDhcp()
{
return this.dhcpOptionDAO.findAll();
}
/**
* 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);
}
/**
* 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 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);
}
public List<RemoteService> findAllRemoteServices()
{
return remoteServiceDao.findAll();
}
/**
* 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 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<UcsRack> findAllUcsRacksByDatacenter(final Datacenter datacenter,
final String filter)
{
return this.ucsRackDao.findAllUcsRacksByDatacenter(datacenter, filter);
}
public Datacenter findById(final Integer id)
{
return this.dao.get(id);
}
public Datacenter findById(final Integer id, final Integer idScope)
{
return this.dao.findById(id, idScope);
}
// Populate requireds
public Datacenter findByName(final String name)
{
return dao.findUniqueByProperty(Datacenter.NAME_PROPERTY, name);
}
public Datacenter findByUuid(final String uuid)
{
return dao.findUniqueByProperty(Datacenter.UUID_PROPERTY, uuid);
}
public Datacenter findByVlan(final VLANNetwork vlan)
{
return dao.findByVlan(vlan);
}
public Collection<Machine> findCandidateMachinesHA(final Integer idRack,
final Integer idVirtualDatacenter, final Enterprise enterprise,
final Integer originalHypervisorId, final String datastoreUUID,
final List<NetworkServiceType> nsts, final String layerName,
final Integer idVirtualAppliance)
{
return machineDao.findCandidateMachines(idRack, idVirtualDatacenter, enterprise,
originalHypervisorId, datastoreUUID, nsts, layerName, idVirtualAppliance);
}
public List<Machine> findCandidateMachines(final Integer idRack,
final Integer idVirtualDatacenter, final Long hdRequiredOnDatastore,
final Enterprise enterprise, final List<NetworkServiceType> nsts, final String layerName,
final Integer idVirtualAppliance)
{
return machineDao.findCandidateMachines(idRack, idVirtualDatacenter, hdRequiredOnDatastore,
enterprise, nsts, layerName, idVirtualAppliance);
}
public Collection<DatacenterLimits> findDatacenterLimits(final Enterprise enterprise)
{
return datacenterLimitDao.findByEnterprise(enterprise);
}
public DatacenterLimits findDatacenterLimits(final Enterprise enterprise,
final Datacenter datacenter)
{
return datacenterLimitDao.findByEnterpriseAndDatacenter(enterprise, datacenter);
}
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 DhcpOption findDhcpOptionById(final Integer id)
{
return dhcpOptionDAO.findById(id);
}
public List<Enterprise> findEnterprisesByDataCenter(final Datacenter datacenter,
final Boolean network, final Integer firstElem, final Integer numElem, final int idScope,
final String filter)
{
PagedList<Enterprise> enterprises = new PagedList<Enterprise>();
enterprises =
(PagedList<Enterprise>) this.dao.findEnterprisesByDatacenters(datacenter, firstElem,
numElem, network, idScope, filter);
return enterprises;
}
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());
}
/**
* 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);
}
/**
* 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);
}
public List<NetworkInterface> findListNetworkInterfaceByNetworkServiceType(
final NetworkServiceType nst)
{
return this.niDAO.findListNetworkInterfaceByServiceType(nst);
}
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 Machine findMachineByName(final String name)
{
return machineDao.findUniqueByProperty(Machine.NAME_PROPERTY, name);
}
public List<Datastore> findMachineDatastores(final Machine machine)
{
assert machine != null;
return datastoreDao.findMachineDatastores(machine);
}
public List<Machine> findMachines(final Datacenter datacenter)
{
return this.machineDao.findMachines(datacenter);
}
public List<Machine> findMachinesWithHAInProgress()
{
return machineDao.findMachinesWithHAInProgress();
}
public NetworkInterface findNetworkInterfaceByName(final Machine machine, final String name)
{
return this.niDAO.findNetworkInterfaceByName(machine, name);
}
public NetworkInterface findNetworkInterfaceByNetworkServiceType(final Machine machine,
final NetworkServiceType nst)
{
return this.niDAO.findNetworkInterfaceByServiceType(machine, nst);
}
public NetworkServiceType findNetworkServiceTypeByDatacenterAndId(final Datacenter datacenter,
final Integer id)
{
return this.netServiceTypeDAO.findByDatacenterAndId(datacenter, id);
}
public NetworkServiceType findNetworkServiceTypeByDatacenterAndName(
final Datacenter datacenter, final String name)
{
return this.netServiceTypeDAO.findByDatacenterAndName(datacenter, name);
}
public NetworkServiceType findNetworkServiceTypeByDefaultInDatacenter(
final Datacenter datacenter)
{
return this.netServiceTypeDAO.findDefaultByDatacenter(datacenter);
}
public List<NetworkServiceType> findNetworkServiceTypesByDatacenter(final Datacenter datacenter)
{
return this.netServiceTypeDAO.findByDatacenter(datacenter);
}
public Integer findNumberNotAssignedNetworkInterfaces(final Machine machine)
{
return niDAO.findNumberNotAssignedNetworkInterfaces(machine);
}
/**
* 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);
}
public List<Machine> findRackBookableMachines(final Rack rack, final Integer enterpriseId)
{
return this.machineDao.findRackBookableMachines(rack, enterpriseId);
}
public Rack findRackById(final Integer id)
{
assert id != null;
return this.rackDao.findById(id);
}
public Rack findRackByIds(final Integer datacenterId, final Integer rackId)
{
return rackDao.findByIds(datacenterId, rackId);
}
public Rack findRackByName(final String name)
{
return rackDao.findUniqueByProperty(Rack.NAME_PROPERTY, name);
}
public List<Machine> findRackEnabledForHAMachines(final Rack rack)
{
return machineDao.findRackEnabledForHAMachines(rack);
}
public List<Machine> findRackMachines(final Rack rack)
{
return findRackMachines(rack, null);
}
public List<Machine> findRackMachines(final Rack rack, final String filter)
{
return this.machineDao.findRackMachines(rack, filter);
}
public Integer countRackMachinesManaged(final Rack rack)
{
return machineDao.numRackMachinesManaged(rack);
}
public List<Rack> findRacks(final Datacenter datacenter)
{
return findRacks(datacenter, null);
}
public List<Rack> findRacks(final Datacenter datacenter, final String filter)
{
return this.rackDao.findRacks(datacenter, filter);
}
public List<Rack> findRacksWithHAEnabled(final Datacenter dc)
{
return rackDao.findRacksWithHAEnabled(dc);
}
public RemoteService findRemoteServiceById(final int id)
{
return remoteServiceDao.findById(id);
}
public List<RemoteService> findRemoteServicesByDatacenter(final Datacenter datacenter)
{
return remoteServiceDao.findByDatacenter(datacenter);
}
public List<RemoteService> findRemoteServiceWithTypeInDatacenter(final Datacenter datacenter,
final RemoteServiceType type)
{
return remoteServiceDao.findByDatacenterAndType(datacenter, type);
}
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 List<NetworkInterface> findSharedNetworkInterfaceByName(final String sharedIp,
final String name, final Integer excludedId)
{
return this.niDAO.findSharedNetworkInterfaceByName(sharedIp, name, excludedId);
}
public List<Datastore> findShares(final Datastore datastore)
{
return this.datastoreDao.findShares(datastore);
}
public UcsRack findUcsRackById(final Integer rackId)
{
return ucsRackDao.findById(rackId);
}
/**
* The vdrp port is at rack level because some hypervisors (ESXi) does not check port collision
* when moving machines. To avoid having more than one virtual machine listening to the same
* port we select and empty port in the rack.
*
* @param rack {@link Rack} that holds the {@link Machine}.
* @return a list of ports attached.
*/
public List<Integer> findUsedRemoteDesktopPortsInRack(final Rack rack)
{
return rackDao.findUsedVrdpPorts(rack);
}
public VirtualMachine findVirtualMachineByHypervisor(final Hypervisor hypervisor,
final Integer vmId)
{
return virtualMachineDao.findVirtualMachineByHypervisor(hypervisor, vmId);
}
/**
* Return all the external/unmanaged VLANs by Datacenter and Enterprise.
*
* @param datacenter {@link Datacenter} where we search for.
* @param enterpriseId identifier of the Enterprise to search into.
* @return list of found {@link VLANNetwork}
*/
public List<VLANNetwork> findVLANNetworksByDatacenterAndEnterprise(final Datacenter datacenter,
final Enterprise enterprise)
{
return vlanDao.findVLANNetworksByDatacenterAndEnterprise(datacenter, enterprise);
}
/**
* 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 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);
}
public List<VirtualMachine> getNotManagedVirtualMachines(final Hypervisor hypervisor)
{
return virtualMachineDao.getNotManagedVirtualMachines(hypervisor);
}
public Long getNumberOfDeployedVlanNetworksByRack(final Integer rackId)
{
return rackDao.getNumberOfDeployedVlanNetworks(rackId);
}
public List<PricingTemplate> getPricingTemplates()
{
return pricingRep.findPricingTemplats();
}
/**
* 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);
}
/**
* 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 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);
}
public VlanRange getUsedRange(final Rack rack)
{
return rackDao.getUsedRange(rack);
}
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 void insertDatastore(final Datastore datastore)
{
datastoreDao.persist(datastore);
datastoreDao.flush();
}
public void insertDhcpOption(final DhcpOption opt)
{
assert opt != null;
assert !dhcpOptionDAO.isManaged(opt);
dhcpOptionDAO.persist(opt);
dhcpOptionDAO.flush();
}
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 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 insertNetwork(final Network network)
{
this.networkDao.persist(network);
this.networkDao.flush();
}
public NetworkInterface insertNetworkInterface(final NetworkInterface ni)
{
niDAO.persist(ni);
return ni;
}
public NetworkServiceType insertNetworkServiceType(final NetworkServiceType nst)
{
netServiceTypeDAO.persist(nst);
return nst;
}
public void insertPricingTier(final PricingTier pricingTier)
{
pricingRep.insertPricingTier(pricingTier);
}
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 insertRemoteService(final RemoteService remoteService)
{
this.remoteServiceDao.persist(remoteService);
this.remoteServiceDao.flush();
}
public void insertTier(final Tier tier)
{
storageRep.insertTier(tier);
}
public void insertUcsRack(final UcsRack UcsRack)
{
this.ucsRackDao.persist(UcsRack);
this.ucsRackDao.flush();
}
public boolean isRepositoryBeingUsed(final Datacenter datacenter)
{
return repositoryDao.isBeingUsed(datacenter);
}
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 void updateDatastore(final Datastore datastore)
{
assert datastore != null;
assert datastoreDao.isManaged(datastore);
datastoreDao.flush();
}
public void updateLimits(final DatacenterLimits dclimits)
{
datacenterLimitDao.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 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 updateRemoteService(final RemoteService remoteService)
{
remoteServiceDao.flush();
}
public void updateRepositoryLocation(final Datacenter datacenter, final String url)
{
repositoryDao.updateRepositoryLocation(datacenter, url);
}
public VLANNetwork getVlanById(final Integer vlanId)
{
return vlanDao.findVlanById(vlanId);
}
}