/**
* 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.cloud;
import java.util.Arrays;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.LockModeType;
import javax.persistence.TypedQuery;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
import com.abiquo.server.core.appslibrary.VirtualMachineTemplate;
import com.abiquo.server.core.cloud.VirtualMachine.OrderByEnum;
import com.abiquo.server.core.common.persistence.DefaultDAOBase;
import com.abiquo.server.core.common.persistence.JPAConfiguration;
import com.abiquo.server.core.enterprise.Enterprise;
import com.abiquo.server.core.enterprise.User;
import com.abiquo.server.core.infrastructure.Datacenter;
import com.abiquo.server.core.util.PagedList;
import com.softwarementors.bzngine.entities.PersistentEntity;
@Repository("jpaVirtualMachineDAO")
public class VirtualMachineDAO extends DefaultDAOBase<Integer, VirtualMachine>
{
public static final String BY_VAPP_AND_ID =
"SELECT nvi.virtualMachine " + "FROM NodeVirtualImage nvi "
+ "WHERE nvi.virtualAppliance.id = :vapp_id AND nvi.virtualMachine.id = :vm_id";
private static Criterion equalName(final String name)
{
assert !StringUtils.isEmpty(name);
return Restrictions.eq(Datacenter.NAME_PROPERTY, name);
}
private static Criterion sameEnterprise(final Enterprise enterprise)
{
assert enterprise != null;
return Restrictions.eq(VirtualMachine.ENTERPRISE_PROPERTY, enterprise);
}
private static Criterion sameHypervisor(final Hypervisor hypervisor)
{
assert hypervisor != null;
return Restrictions.eq(VirtualMachine.HYPERVISOR_PROPERTY, hypervisor);
}
private static Criterion sameUser(final User user)
{
return Restrictions.eq(VirtualMachine.USER_PROPERTY, user);
}
public VirtualMachineDAO()
{
super(VirtualMachine.class);
}
public VirtualMachineDAO(final EntityManager entityManager)
{
super(VirtualMachine.class, entityManager);
}
public List<VirtualMachine> getNotManagedVirtualMachines(final Hypervisor hypervisor)
{
Criteria criteria = createCriteria(sameHypervisor(hypervisor), notManaged());
return getResultList(criteria);
}
public boolean existsAnyWithName(final String name)
{
assert !StringUtils.isEmpty(name);
return this.existsAnyByCriterions(equalName(name));
}
public VirtualMachine findByIdByVirtualApp(final VirtualAppliance vapp, final Integer vmId)
{
Query finalQuery = getSession().createQuery(BY_VAPP_AND_ID);
finalQuery.setParameter("vapp_id", vapp.getId());
finalQuery.setParameter("vm_id", vmId);
return (VirtualMachine) finalQuery.uniqueResult();
}
public VirtualMachine findByName(final String name)
{
return findUniqueByProperty(VirtualMachine.NAME_PROPERTY, name);
}
public VirtualMachine findByUUID(final String uuid)
{
return findUniqueByProperty(VirtualMachine.UUID_PROPERTY, uuid);
}
public List<VirtualMachine> findManagedVirtualMachines(final Hypervisor hypervisor)
{
assert hypervisor != null;
assert isManaged2(hypervisor);
Criteria criteria = createCriteria(sameHypervisor(hypervisor), managed());
criteria.addOrder(Order.asc(VirtualMachine.NAME_PROPERTY));
List<VirtualMachine> result = getResultList(criteria);
return result;
}
public VirtualMachine findVirtualMachineByHypervisor(final Hypervisor hypervisor,
final Integer virtualMachineId)
{
Criteria criteria =
createCriteria(sameHypervisor(hypervisor), Restrictions.eq(
PersistentEntity.ID_PROPERTY, virtualMachineId));
return (VirtualMachine) criteria.uniqueResult();
}
public List<VirtualMachine> findVirtualMachines(final Hypervisor hypervisor)
{
assert hypervisor != null;
assert isManaged2(hypervisor);
Criteria criteria = createCriteria(sameHypervisor(hypervisor));
criteria.addOrder(Order.asc(VirtualMachine.NAME_PROPERTY));
List<VirtualMachine> result = getResultList(criteria);
return result;
}
// without hypervisor
public List<VirtualMachine> findVirtualMachinesNotAllocatedCompatibleHypervisor(
final Hypervisor hypervisor)
{
Criteria criteria = createCriteria();
criteria.createAlias(VirtualMachine.VIRTUAL_MACHINE_TEMPLATE_PROPERTY, "template");
Restrictions.and(Restrictions.eq(VirtualMachine.HYPERVISOR_PROPERTY, null), Restrictions
.in("template." + VirtualMachineTemplate.DISKFORMAT_TYPE_PROPERTY, Arrays
.asList(hypervisor.getType().compatibleFormats)));
criteria.addOrder(Order.asc(VirtualMachine.NAME_PROPERTY));
List<VirtualMachine> result = getResultList(criteria);
return result;
}
public List<VirtualMachine> findVirtualMachinesByDatacenter(final Integer datacenterId)
{
List<VirtualMachine> vmList = null;
TypedQuery<VirtualMachine> query =
getEntityManager().createNamedQuery("VIRTUAL_MACHINE.BY_DC", VirtualMachine.class);
query.setParameter("datacenterId", datacenterId);
vmList = query.getResultList();
return vmList;
}
public List<VirtualMachine> findVirtualMachinesByEnterprise(final Enterprise enterprise)
{
assert enterprise != null;
assert isManaged2(enterprise);
Criteria criteria = createCriteria(sameEnterprise(enterprise));
criteria.addOrder(Order.asc(VirtualMachine.NAME_PROPERTY));
List<VirtualMachine> result = getResultList(criteria);
return result;
}
public List<VirtualMachine> findVirtualMachinesByUser(final Enterprise enterprise,
final User user)
{
Criteria criteria = createCriteria(sameUser(user)).add(sameEnterprise(enterprise));
criteria.addOrder(Order.asc(VirtualMachine.NAME_PROPERTY));
List<VirtualMachine> result = getResultList(criteria);
return result;
}
public List<VirtualMachine> findVirtualMachinesByVirtualAppliance(final Integer vappId,
Integer startwith, Integer limit, final String filter, final OrderByEnum orderby,
final boolean asc)
{
// List<VirtualMachine> vmList = null;
// TypedQuery<VirtualMachine> query =
// getEntityManager().createNamedQuery("VIRTUAL_MACHINE.BY_VAPP", VirtualMachine.class);
// query.setParameter("vapp_id", vappId);
// vmList = query.getResultList();
String orderBy = defineOrderBy(orderby.getColumnHQL(), asc);
Query query = getSession().getNamedQuery("VIRTUAL_MACHINE.BY_VAPP");
String req = query.getQueryString() + orderBy;
// Add order filter to the query
Query queryWithOrder = getSession().createQuery(req);
queryWithOrder.setInteger("vapp_id", vappId);
queryWithOrder.setString("filterLike", filter.isEmpty() ? "%" : "%" + filter + "%");
Integer size = queryWithOrder.list().size();
// Limit 0 means no size filter
if (limit == 0)
{
limit = size;
startwith = 0;
}
queryWithOrder.setFirstResult(startwith);
queryWithOrder.setMaxResults(limit);
PagedList<VirtualMachine> vmList = new PagedList<VirtualMachine>(queryWithOrder.list());
vmList.setTotalResults(size);
vmList.setPageSize(limit > size ? size : limit);
vmList.setCurrentElement(startwith);
return vmList;
}
public List<VirtualMachine> findByVirtualMachineTemplate(final Integer virtualMachineTemplateId)
{
List<VirtualMachine> vmList = null;
TypedQuery<VirtualMachine> query =
getEntityManager().createNamedQuery("VIRTUAL_MACHINE.BY_VMT", VirtualMachine.class);
query.setParameter("virtualMachineTplId", virtualMachineTemplateId);
vmList = query.getResultList();
return vmList;
}
public boolean hasVirtualMachineTemplate(final Integer virtualMachineTemplateId)
{
TypedQuery<Long> query =
getEntityManager().createNamedQuery("VIRTUAL_MACHINE.HAS_VMT", Long.class);
query.setParameter("virtualMachineTplId", virtualMachineTemplateId);
return query.getResultList().get(0) > 0;
}
public void updateVirtualMachineState(final Integer vmachineId, final VirtualMachineState state)
{
VirtualMachine vmachine = findById(vmachineId);
vmachine.setState(state);
flush();
}
/**
* Sets the {@link VirtualMachine#setState(VirtualMachineState)} to
* {@link VirtualMachineState#UNKNOWN}.
*
* @param vmachineId id void
*/
public void unknownState(final Integer vmachineId)
{
VirtualMachine vmachine = findById(vmachineId);
vmachine.setState(VirtualMachineState.UNKNOWN);
}
private Criterion managed()
{
return Restrictions.eq(VirtualMachine.ID_TYPE_PROPERTY, VirtualMachine.MANAGED);
}
private Criterion notManaged()
{
return Restrictions.eq(VirtualMachine.ID_TYPE_PROPERTY, VirtualMachine.NOT_MANAGED);
}
private Criteria temporalVirtualMachine(final Integer vmachineId)
{
return createCriteria(Restrictions.eq(VirtualMachine.TEMPORAL_PROPERTY, vmachineId));
}
public VirtualMachine findBackup(final VirtualMachine vmachine)
{
try
{
JPAConfiguration.enableOnlyTemporalFilters(getEntityManager());
return getSingleResult(temporalVirtualMachine(vmachine.getId()));
}
finally
{
JPAConfiguration.enableDefaultFilters(getEntityManager());
}
}
public void refreshLock(final VirtualMachine vm)
{
// We force the refresh from database (PESSIMISTIC) and increment the version of the object
// (INCREMENT) to ensure that no other code will be using the "unlocked" object.
getEntityManager().refresh(vm, LockModeType.PESSIMISTIC_FORCE_INCREMENT);
}
public void refresh(final VirtualMachine vm)
{
getEntityManager().refresh(vm);
}
public void detachHypervisor(final VirtualMachine vm)
{
getEntityManager().detach(vm.getHypervisor());
}
public void detachVirtualMachine(final VirtualMachine vm)
{
getEntityManager().detach(vm);
}
public void deleteNotManagedVirtualMachines(final Hypervisor hypervisor)
{
Criteria criteria = createCriteria(sameHypervisor(hypervisor), notManaged());
List<VirtualMachine> notManaged = getResultList(criteria);
for (VirtualMachine vm : notManaged)
{
remove(vm);
}
flush();
}
private String defineOrderBy(final String orderBy, final Boolean asc)
{
StringBuilder queryString = new StringBuilder();
queryString.append(" order by ");
queryString.append(orderBy);
queryString.append(" ");
if (asc)
{
queryString.append("asc");
}
else
{
queryString.append("desc");
}
return queryString.toString();
}
}