/**
* 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.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
import com.abiquo.model.enumerator.HypervisorType;
import com.abiquo.model.enumerator.MachineState;
import com.abiquo.server.core.cloud.Hypervisor;
import com.abiquo.server.core.common.persistence.DefaultDAOBase;
import com.abiquo.server.core.enterprise.Enterprise;
import com.softwarementors.bzngine.entities.PersistentEntity;
@Repository("jpaMachineDAO")
@SuppressWarnings("unchecked")
public class MachineDAO extends DefaultDAOBase<Integer, Machine>
{
public MachineDAO()
{
super(Machine.class);
}
public MachineDAO(final EntityManager entityManager)
{
super(Machine.class, entityManager);
}
private static Criterion sameDatacenter(final Datacenter datacenter)
{
assert datacenter != null;
return Restrictions.eq(Machine.DATACENTER_PROPERTY, datacenter);
}
private static Criterion sameRack(final Rack rack)
{
assert rack != null;
return Restrictions.eq(Machine.RACK_PROPERTY, rack);
}
private static Criterion sameId(final Integer id)
{
return Restrictions.eq(PersistentEntity.ID_PROPERTY, id);
}
private static Criterion sameName(final String name)
{
assert !StringUtils.isEmpty(name);
return Restrictions.eq(Machine.NAME_PROPERTY, name);
}
private Criterion sameEnterprise(final Enterprise enterprise)
{
return Restrictions.eq(Machine.ENTERPRISE_PROPERTY, enterprise);
}
private static Criterion sameState(final MachineState state)
{
return Restrictions.eq(Machine.STATE_PROPERTY, state);
}
private Criterion filterBy(final String filter)
{
Disjunction filterDisjunction = Restrictions.disjunction();
filterDisjunction.add(Restrictions.like(Machine.NAME_PROPERTY, '%' + filter + '%'));
return filterDisjunction;
}
public List<Machine> findMachines(final Datacenter datacenter)
{
Criteria criteria = createCriteria(sameDatacenter(datacenter));
criteria.addOrder(Order.asc(Machine.NAME_PROPERTY));
List<Machine> result = getResultList(criteria);
return result;
}
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 isManaged2(rack);
Criteria criteria = createCriteria(sameRack(rack));
if (filter != null && !filter.isEmpty())
{
criteria.add(filterBy(filter));
}
criteria.addOrder(Order.asc(Machine.NAME_PROPERTY));
List<Machine> result = getResultList(criteria);
return result;
}
public List<Machine> findMachinesWithHAInProgress()
{
Criteria criteria = createCriteria(sameState(MachineState.HA_IN_PROGRESS));
criteria.createAlias(Machine.HYPERVISOR_PROPERTY, "hypervisor");
// Order by name
criteria.addOrder(Order.asc(Machine.NAME_PROPERTY));
return getResultList(criteria);
}
public List<Machine> findRackEnabledForHAMachines(final Rack rack)
{
if (rack instanceof UcsRack)
{
return findRackEnabledForHAMachinesInUcs((UcsRack) rack);
}
Criteria criteria = createCriteria(sameRack(rack));
criteria.createAlias(Machine.HYPERVISOR_PROPERTY, "hypervisor");
// Is a managed one
criteria.add(Restrictions.eq(Machine.STATE_PROPERTY, MachineState.MANAGED));
// Has fencing capabilities
criteria.add(Restrictions.isNotNull(Machine.IPMI_IP_PROPERTY));
criteria.add(Restrictions.isNotNull(Machine.IPMI_USER_PROPERTY));
criteria.add(Restrictions.isNotNull(Machine.IPMI_PASSWORD_PROPERTY));
// XenServer does not support HA
criteria.add(Restrictions.ne("hypervisor." + Hypervisor.TYPE_PROPERTY,
HypervisorType.XENSERVER));
// Order by name
criteria.addOrder(Order.asc(Machine.NAME_PROPERTY));
return getResultList(criteria);
}
public List<Machine> findRackEnabledForHAMachinesInUcs(final UcsRack rack)
{
Criteria criteria = createCriteria(sameRack(rack));
criteria.createAlias(Machine.HYPERVISOR_PROPERTY, "hypervisor");
// Is a managed one
criteria.add(Restrictions.eq(Machine.STATE_PROPERTY, MachineState.MANAGED));
// XenServer does not support HA
criteria.add(Restrictions.ne("hypervisor." + Hypervisor.TYPE_PROPERTY,
HypervisorType.XENSERVER));
// Order by name
criteria.addOrder(Order.asc(Machine.NAME_PROPERTY));
return getResultList(criteria);
}
public boolean existsAnyWithDatacenterAndName(final Datacenter datacenter, final String name)
{
assert datacenter != null;
assert !StringUtils.isEmpty(name);
return existsAnyByCriterions(sameDatacenter(datacenter), sameName(name));
}
public boolean existsAnyOtherWithDatacenterAndName(final Machine machine, final String name)
{
assert machine != null;
assert !StringUtils.isEmpty(name);
return existsAnyOtherByCriterions(machine, sameDatacenter(machine.getDatacenter()),
sameName(name));
}
public int deleteRackMachines(final Rack rack)
{
assert rack != null;
assert isManaged2(rack);
Collection<Machine> machines = findRackMachines(rack);
for (Machine machine : machines)
{
remove(machine);
}
return machines.size();
}
public List<Machine> findCandidateMachines(final Integer idRack,
final Integer idVirtualDatacenter, final Long hdRequiredOnDatastore,
final Enterprise enterprise)
{
List<Machine> machines;
if (enterprise.getIsReservationRestricted())
{
machines =
findFirstCandidateMachinesReservedRestricted(idRack, idVirtualDatacenter,
hdRequiredOnDatastore, enterprise);
}
else
{
machines =
findFirstCandidateMachines(idRack, idVirtualDatacenter, hdRequiredOnDatastore,
enterprise);
}
// StringBuilder sbcandidates = new StringBuilder();
List<Integer> candidatesids = new LinkedList<Integer>();
for (Machine m : machines)
{
candidatesids.add(m.getId());
}
// with datastore
Query datastoreQuery = getSession().createQuery(QUERY_CANDIDATE_DATASTORE);
datastoreQuery.setLong("hdRequiredOnRepository", hdRequiredOnDatastore);
datastoreQuery.setParameterList("candidates", candidatesids);
List<Integer> includedIds = datastoreQuery.list();
if (includedIds.size() == 0)
{
throw new PersistenceException(String.format(
"There isn't any machine with the required datastore capacity [%d]",
hdRequiredOnDatastore));
}
// execute the enterprise exclusion rule
Query excludedQuery = getSession().createQuery(QUERY_CANDIDATE_NO_ENTERPRISE_EXCLUDED);
excludedQuery.setParameter("enterpriseId", enterprise.getId());
List<Integer> excludedMachineIds = excludedQuery.list();
List<Machine> notExcludedMachines = new LinkedList<Machine>();
for (Machine m : machines)
{
Integer machineId = m.getId();
if (!excludedMachineIds.contains(machineId) && includedIds.contains(machineId))
{
notExcludedMachines.add(m);
}
}
if (notExcludedMachines.size() == 0)
{
throw new PersistenceException("All the candiate machines are excluded by other enterprsies "
+ "with virtual machines deployed on it. Please check the enterprise affinity rules.");
}
return notExcludedMachines;
}
private List<Machine> findFirstCandidateMachines(final Integer idRack,
final Integer idVirtualDatacenter, final Long hdRequiredOnDatastore,
final Enterprise enterprise)
{
List<Machine> machines = null;
Query query = getSession().createQuery(QUERY_CANDIDATE_MACHINES);
query.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query.setInteger("idRack", idRack);
query.setParameter("state", MachineState.MANAGED);
query.setParameter("enterpriseId", enterprise.getId());
machines = query.list();
if (machines == null || machines.size() == 0)
{
whyNotCandidateMachines(idRack, idVirtualDatacenter, hdRequiredOnDatastore, enterprise,
null);
}
return machines;
}
private List<Machine> findFirstCandidateMachinesReservedRestricted(final Integer idRack,
final Integer idVirtualDatacenter, final Long hdRequiredOnDatastore,
final Enterprise enterprise)
{
List<Machine> machines = null;
List<Machine> reservMachines = findReservedMachines(enterprise);
if (reservMachines != null && reservMachines.size() != 0)
{
List<Integer> reserveds = new LinkedList<Integer>();
for (Machine m : reservMachines)
{
reserveds.add(m.getId());
}
Query query = getSession().createQuery(QUERY_CANDIDATE_MACHINES_RESERVED);
query.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query.setInteger("idRack", idRack);
query.setParameter("state", MachineState.MANAGED);
query.setParameterList("reserveds", reserveds);
machines = query.list();
if (machines == null || machines.size() == 0)
{
whyNotCandidateMachines(idRack, idVirtualDatacenter, hdRequiredOnDatastore,
enterprise, reserveds);
}
return machines;
}
else
{
final String msg =
String
.format(
"Enterprise works in restricted reserved machines mode but no machine is reserved. Current enterprise: %s",
enterprise.getName());
throw new PersistenceException(msg);
}
}
protected List<Machine> findFirstCandidateMachinesReservedRestrictedHAExclude(
final Integer idRack, final Integer idVirtualDatacenter, final Enterprise enterprise,
final Integer originalHypervisorId)
{
List<Machine> machines = null;
List<Machine> reservMachines = findReservedMachines(enterprise);
if (reservMachines != null && reservMachines.size() != 0)
{
List<Integer> reserveds = new LinkedList<Integer>();
for (Machine m : reservMachines)
{
reserveds.add(m.getId());
}
Query query =
getSession().createQuery(QUERY_CANDIDATE_MACHINES_RESERVED_HA_EXCLUDE_ORIGINAL);
query.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query.setInteger("idRack", idRack);
query.setParameter("state", MachineState.MANAGED);
query.setParameterList("reserveds", reserveds);
query.setInteger("enterpriseId", enterprise.getId());
query.setInteger("originalHypervisorId", originalHypervisorId);
machines = query.list();
if (machines == null || machines.size() == 0)
{
whyNotCandidateMachines(idRack, idVirtualDatacenter, 0l, enterprise, reserveds);
}
return machines;
}
else
{
final String msg =
String
.format(
"Enterprise works in restricted reserved machines mode but no machine is reserved. Current enterprise: %s",
enterprise.getName());
throw new PersistenceException(msg);
}
}
/**
* Do not require additional space on the datastore. Used during HA, selects a machine different
* of the ''originalHypervisorId'' with the same ''datastoreUuid'' enabled.
*/
public List<Machine> findCandidateMachines(final Integer idRack,
final Integer idVirtualDatacenter, final Enterprise enterprise, final String datastoreUuid,
final Integer originalHypervisorId)
{
List<Machine> machines = null;
if (enterprise.getIsReservationRestricted())
{
machines =
findFirstCandidateMachinesReservedRestrictedHAExclude(idRack, idVirtualDatacenter,
enterprise, originalHypervisorId);
}
else
{
Query query = getSession().createQuery(QUERY_CANDIDATE_MACHINES_HA_EXCLUDE_ORIGINAL);
query.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query.setInteger("idRack", idRack);
query.setParameter("state", MachineState.MANAGED);
query.setParameter("enterpriseId", enterprise.getId());
query.setParameter("originalHypervisorId", originalHypervisorId);
machines = query.list();
}
if (machines == null || machines.size() == 0)
{
Query query = getSession().createQuery(QUERY_CANDIDATE_MACHINES);
query.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query.setInteger("idRack", idRack);
query.setParameter("state", MachineState.MANAGED);
query.setParameter("enterpriseId", enterprise.getId());
machines = query.list();
if (machines == null || machines.size() == 0)
{
throw new PersistenceException(String.format(
"There isn't any MANAGED machine on the required rack [%d] and virtual datacenter [%d] available for the current enterpirse [%s]. "
+ "Pleas check the machine reservation policies.", idRack,
idVirtualDatacenter, enterprise.getName()));
}
else
{
throw new PersistenceException(String.format(
"The only MANAGED machine on the required rack [%d] and virtual datacenter [%d] available for the current enterpirse [%s]"
+ "is the target of the high availability (so can't be used) ", idRack,
idVirtualDatacenter, enterprise.getName()));
}
}
// StringBuilder sbcandidates = new StringBuilder();
List<Integer> candidatesids = new LinkedList<Integer>();
for (Machine m : machines)
{
candidatesids.add(m.getId());
}
// with datastore
Query datastoreQuery = getSession().createQuery(QUERY_CANDIDATE_DATASTORE_HA_DATASTOREUUID);
datastoreQuery.setParameterList("candidates", candidatesids);
datastoreQuery.setParameter("datastoreUuid", datastoreUuid);
List<Integer> includedIds = datastoreQuery.list();
if (includedIds.size() == 0)
{
throw new PersistenceException(String.format(
"There isn't any machine with the required shared datastore [%s]", datastoreUuid));
}
// execute the enterprise exclusion rule
Query excludedQuery = getSession().createQuery(QUERY_CANDIDATE_NO_ENTERPRISE_EXCLUDED);
excludedQuery.setParameter("enterpriseId", enterprise.getId());
List<Integer> excludedMachineIds = excludedQuery.list();
List<Machine> notExcludedMachines = new LinkedList<Machine>();
for (Machine m : machines)
{
Integer machineId = m.getId();
if (!excludedMachineIds.contains(machineId) && includedIds.contains(machineId))
{
notExcludedMachines.add(m);
}
}
if (notExcludedMachines.size() == 0)
{
throw new PersistenceException("All the candiate machines are excluded by other enterprsies "
+ "with virtual machines deployed on it. Please check the enterprise affinity rules.");
}
return notExcludedMachines;
}
private void whyNotCandidateMachines(final Integer idRack, final Integer idVirtualDatacenter,
final Long hdRequiredOnDatastore, final Enterprise enterprise, final List<Integer> reserveds)
throws PersistenceException
{
if (reserveds != null)
{
StringBuilder reservedMachinesB =
new StringBuilder(String.format(
"Enterprise %s has the following machine reservations : ", enterprise.getName()));
for (Integer mid : reserveds)
{
reservedMachinesB.append(mid + ' ');
}
/**
* rack and hypervisor type
*/
Query query1 =
getSession().createQuery(WHY_QUERY_CANDIDATE_SAME_VDC_RACK_AND_TYPE_AND_RESERVED);
query1.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query1.setInteger("idRack", idRack);
query1.setParameterList("reserveds", reserveds);
List<Integer> query1res = query1.list();
if (query1res.size() == 0)
{
throw new PersistenceException(String.format(
"%s\nThere isn't any machine on the required rack [%d] and virtual datacenter [%d]. "
+ "Please check the racks and hypervisor technology on the infrastructure.",
reservedMachinesB.toString(), idRack, idVirtualDatacenter));
}
/**
* rack, hypervisor type and managed state
*/
Query query2 = getSession().createQuery(QUERY_CANDIDATE_MACHINES_RESERVED);
query2.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query2.setInteger("idRack", idRack);
query2.setParameter("state", MachineState.MANAGED);
query2.setParameterList("reserveds", reserveds);
List<Integer> query2res = query2.list();
if (query2res.size() == 0)
{
throw new PersistenceException(String.format(
"%s\nThere isn't any MANAGED machine on the required rack [%d] and virtual datacenter [%d]. "
+ "Please check the machine health on the infrastructure.",
reservedMachinesB.toString(), idRack, idVirtualDatacenter));
}
/**
* rack, hypervisor type, managed state, enterprise reservation and datastore capacity.
*/
throw new PersistenceException(String.format(
"%s\nThere isn't any machine with the required datastore capacity [%d]",
reservedMachinesB.toString(), hdRequiredOnDatastore));
} // reserved machines
else
{
/**
* rack and hypervisor type
*/
Query query1 = getSession().createQuery(WHY_QUERY_CANDIDATE_SAME_VDC_RACK_AND_TYPE);
query1.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query1.setInteger("idRack", idRack);
List<Integer> query1res = query1.list();
if (query1res.size() == 0)
{
throw new PersistenceException(String.format(
"There isn't any machine on the required rack [%d] and virtual datacenter [%d]. "
+ "Please check the racks and hypervisor technology on the infrastructure.",
idRack, idVirtualDatacenter));
}
/**
* rack, hypervisor type and managed state
*/
Query query2 =
getSession().createQuery(WHT_QUERY_CANDIDATE_SAME_VDC_RACK_AND_TYPE_AND_STATE);
query2.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query2.setInteger("idRack", idRack);
query2.setParameter("state", MachineState.MANAGED);
List<Integer> query2res = query2.list();
if (query2res.size() == 0)
{
throw new PersistenceException(String.format(
"There isn't any MANAGED machine on the required rack [%d] and virtual datacenter [%d]. "
+ "Please check the machine health on the infrastructure.", idRack,
idVirtualDatacenter));
}
/**
* rack, hypervisor type, managed state and enterprise reservation
*/
Query query3 = getSession().createQuery(QUERY_CANDIDATE_MACHINES);
query3.setInteger("idVirtualDataCenter", idVirtualDatacenter);
query3.setInteger("idRack", idRack);
query3.setParameter("state", MachineState.MANAGED);
query3.setParameter("enterpriseId", enterprise.getId());
List<Integer> query3res = query3.list();
if (query3res.size() == 0)
{
throw new PersistenceException(String.format(
"There isn't any MANAGED machine on the required rack [%d] and virtual datacenter [%d] available for the current enterpirse [%s]. "
+ "Pleas check the machine reservation policies.", idRack,
idVirtualDatacenter, enterprise.getName()));
}
/**
* rack, hypervisor type, managed state, enterprise reservation and datastore capacity.
*/
throw new PersistenceException(String.format(
"There isn't any machine with the required datastore capacity [%d]",
hdRequiredOnDatastore));
}
}
public List<Machine> findReservedMachines(final Enterprise enterprise)
{
Criteria criteria = createCriteria(sameEnterprise(enterprise));
criteria.addOrder(Order.asc(Machine.NAME_PROPERTY));
List<Machine> result = getResultList(criteria);
return result;
}
public Machine findReservedMachine(final Enterprise enterprise, final Integer machineId)
{
Criteria criteria = createCriteria(sameEnterprise(enterprise), sameId(machineId));
return (Machine) criteria.uniqueResult();
}
public void reserveMachine(final Machine machine, final Enterprise enterprise)
{
machine.setEnterprise(enterprise);
flush();
}
public void releaseMachine(final Machine machine)
{
machine.setEnterprise(null);
flush();
}
// idVirtualDataCenter, idRack
private final static String WHY_QUERY_CANDIDATE_SAME_VDC_RACK_AND_TYPE = //
"SELECT m.id FROM " + //
"com.abiquo.server.core.infrastructure.Machine m, " + //
"com.abiquo.server.core.cloud.VirtualDatacenter vdc " + //
"WHERE " + //
"vdc.id = :idVirtualDataCenter " + //
"AND m.hypervisor.type = vdc.hypervisorType " + //
"AND m.rack.id = :idRack " + //
"AND m.enterprise is null";
// idVirtualDataCenter, idRack, state
private final static String WHT_QUERY_CANDIDATE_SAME_VDC_RACK_AND_TYPE_AND_STATE = //
"SELECT m.id FROM " + //
"com.abiquo.server.core.infrastructure.Machine m, " + //
"com.abiquo.server.core.cloud.VirtualDatacenter vdc " + //
"WHERE " + //
"vdc.id = :idVirtualDataCenter " + //
"AND m.hypervisor.type = vdc.hypervisorType " + //
"AND m.rack.id = :idRack " + //
"AND m.state = :state " + //
"AND m.enterprise is null";
// reserved, idVirtualDataCenter, idRack
private final static String WHY_QUERY_CANDIDATE_SAME_VDC_RACK_AND_TYPE_AND_RESERVED = //
"SELECT m.id FROM " + //
"com.abiquo.server.core.infrastructure.Machine m, " + //
"com.abiquo.server.core.cloud.VirtualDatacenter vdc " + //
"WHERE m.id in (:reserveds) AND " + //
"vdc.id = :idVirtualDataCenter " + //
"AND m.hypervisor.type = vdc.hypervisorType " + //
"AND m.rack.id = :idRack ";
private final static String QUERY_CANDIDATE_NO_ENTERPRISE_EXCLUDED = //
"SELECT DISTINCT vm.hypervisor.machine.id "
+ //
"FROM com.abiquo.server.core.cloud.VirtualMachine vm WHERE "
+ //
" (vm.enterprise.id IN "
+ " ( SELECT rule.enterprise2.id FROM com.abiquo.server.core.scheduler.EnterpriseExclusionRule rule WHERE rule.enterprise1.id = :enterpriseId )"
+ " ) OR "
+ " (vm.enterprise.id IN "
+ " ( SELECT rule.enterprise1.id FROM com.abiquo.server.core.scheduler.EnterpriseExclusionRule rule WHERE rule.enterprise2.id = :enterpriseId )"
+ " ) "
+ //
" OR " // enterprise doesn't have exlusion rules
+ //
" (vm.enterprise.id IN "
+ " ( SELECT rule.enterprise1.id FROM com.abiquo.server.core.scheduler.EnterpriseExclusionRule rule WHERE rule.enterprise2.id = :enterpriseId )"
+ " ) ";
// idVirtualDataCenter, idRack, state, enterprise
private final static String QUERY_CANDIDATE_MACHINES = //
"SELECT m FROM " + //
"com.abiquo.server.core.infrastructure.Machine m, " + //
"com.abiquo.server.core.cloud.VirtualDatacenter vdc " + //
"WHERE " + //
"vdc.id = :idVirtualDataCenter " + //
"AND m.hypervisor.type = vdc.hypervisorType " + //
"AND m.rack.id = :idRack " + //
"AND m.state = :state " + //
"AND (m.enterprise is null OR m.enterprise.id = :enterpriseId) ";
/**
* HA related
*/
// idVirtualDataCenter, idRack, state, enterprise, originalHypervisorId
private final static String QUERY_CANDIDATE_MACHINES_HA_EXCLUDE_ORIGINAL = //
"SELECT m FROM " + //
"com.abiquo.server.core.infrastructure.Machine m, " + //
"com.abiquo.server.core.cloud.VirtualDatacenter vdc " + //
"WHERE " + //
"vdc.id = :idVirtualDataCenter " + //
"AND m.hypervisor.type = vdc.hypervisorType " + //
"AND m.rack.id = :idRack " + //
"AND m.state = :state " + //
"AND (m.enterprise is null OR m.enterprise.id = :enterpriseId) " + //
"AND m.hypervisor.id <> :originalHypervisorId";
// reserved, idVirtualDataCenter, idRack, state
private final static String QUERY_CANDIDATE_MACHINES_RESERVED = //
"SELECT m FROM " + //
"com.abiquo.server.core.infrastructure.Machine m, " + //
"com.abiquo.server.core.cloud.VirtualDatacenter vdc " + //
"WHERE m.id in (:reserveds) AND " + //
"vdc.id = :idVirtualDataCenter " + //
"AND m.hypervisor.type = vdc.hypervisorType " + //
"AND m.rack.id = :idRack " + //
"AND m.state = :state ";
// reserved, idVirtualDataCenter, idRack, state, enterprise, orignalHypervisorId
private final static String QUERY_CANDIDATE_MACHINES_RESERVED_HA_EXCLUDE_ORIGINAL = //
"SELECT m FROM " + //
"com.abiquo.server.core.infrastructure.Machine m, " + //
"com.abiquo.server.core.cloud.VirtualDatacenter vdc " + //
"WHERE m.id in (:reserveds) AND " + //
"vdc.id = :idVirtualDataCenter " + //
"AND m.hypervisor.type = vdc.hypervisorType " + //
"AND m.rack.id = :idRack " + //
"AND m.state = :state " + //
"AND (m.enterprise is null OR m.enterprise.id = :enterpriseId) " + //
"AND m.hypervisor.id <> :originalHypervisorId";
private final static String QUERY_CANDIDATE_DATASTORE = //
" SELECT py.id FROM " + //
" com.abiquo.server.core.infrastructure.Datastore datastore, " + //
" com.abiquo.server.core.infrastructure.Machine py " + //
" WHERE py.id in (:candidates)" + //
" AND (datastore.size - datastore.usedSize) > :hdRequiredOnRepository " + //
" AND py in elements(datastore.machines) " + //
" AND datastore.size > datastore.usedSize " + //
" AND datastore.enabled = true";
private final static String QUERY_CANDIDATE_DATASTORE_HA_DATASTOREUUID = //
" SELECT py.id FROM " + //
" com.abiquo.server.core.infrastructure.Datastore datastore, " + //
" com.abiquo.server.core.infrastructure.Machine py " + //
" WHERE py.id in (:candidates)" + //
// " AND (datastore.size - datastore.usedSize) > :hdRequiredOnRepository " + //
" AND py in elements(datastore.machines) " + //
" AND datastore.size > datastore.usedSize " + //
" AND datastore.enabled = true " + //
" AND datastore.datastoreUUID = :datastoreUuid";
private static final String QUERY_IS_MACHINE_IN_ALLOCATOR =
"SELECT vm FROM com.abiquo.server.core.cloud.VirtualMachine vm "
+ "join vm.hypervisor h join h.machine m WHERE m.id = :machineId "
+ "AND vm.state != 'RUNNING' AND vm.state != 'POWERED_OFF' "
+ "AND vm.state != 'PAUSED' AND vm.state != 'REBOOTED'";
public Machine findByIds(final Integer datacenterId, final Integer rackId,
final Integer machineId)
{
return findUniqueByCriterions(Restrictions.eq("datacenter.id", datacenterId),
Restrictions.eq("rack.id", rackId), Restrictions.eq("id", machineId));
}
public Machine findByIp(final Datacenter datacenter, final String ip)
{
Criteria crit = createCriteria();
crit.createAlias(Machine.HYPERVISOR_PROPERTY, "hypervisor");
crit.add(sameDatacenter(datacenter));
crit.add(Restrictions.eq("hypervisor.ip", ip));
return (Machine) crit.uniqueResult();
}
public Set<Integer> findAllIds()
{
Set<Integer> ids = new HashSet<Integer>();
List<Machine> machines = findAll();
for (Machine m : machines)
{
ids.add(m.getId());
}
return ids;
}
private static final String QUERY_ALL_IDS_IN =
"SELECT m.id "
+ "FROM com.abiquo.server.core.infrastructure.Machine m WHERE m.datacenter IN (:datacenters)";
/**
* returns machien ids form selected datacenters
*/
public List<Integer> findAllIdsInDatacenters(final Datacenter... datacenters)
{
Query query = getSession().createQuery(QUERY_ALL_IDS_IN);
query.setParameterList("datacenters", datacenters);
return query.list();
}
private static final String QUERY_TOTAL_USED_CORES = "SELECT sum(virtualCpuCores) "
+ "FROM com.abiquo.server.core.infrastructure.Machine";
public Long getTotalUsedCores()
{
Query query = getSession().createQuery(QUERY_TOTAL_USED_CORES);
Long result = (Long) query.uniqueResult();
// If there are no results (no machines in DB) return 0
return result == null ? 0L : result;
}
private static final String QUERY_USED_CORES_EXCEPT_MACHINE = "SELECT sum(virtualCpuCores) "
+ "FROM com.abiquo.server.core.infrastructure.Machine WHERE id != :id";
public Long getTotalUsedCoresExceptMachine(final Machine machine)
{
Query query = getSession().createQuery(QUERY_USED_CORES_EXCEPT_MACHINE);
query.setInteger("id", machine.getId());
Long result = (Long) query.uniqueResult();
// If there are no results (no other machines in DB) return 0
return result == null ? 0L : result;
}
}