com.abiquo.server.core.cloud.VirtualDatacenterDAO.java Source code

Java tutorial

Introduction

Here is the source code for com.abiquo.server.core.cloud.VirtualDatacenterDAO.java

Source

/**
 * 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.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

import javax.persistence.EntityManager;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Transformer;
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.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;

import com.abiquo.server.core.cloud.VirtualDatacenter.OrderByEnum;
import com.abiquo.server.core.common.DefaultEntityCurrentUsed;
import com.abiquo.server.core.common.persistence.DefaultDAOBase;
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.infrastructure.network.VLANNetwork;
import com.abiquo.server.core.util.FilterOptions;
import com.abiquo.server.core.util.PagedList;
import com.softwarementors.bzngine.entities.PersistentEntity;

@Repository("jpaVirtualDatacenterDAO")
@SuppressWarnings("unchecked")
public class VirtualDatacenterDAO extends DefaultDAOBase<Integer, VirtualDatacenter> {
    public VirtualDatacenterDAO() {
        super(VirtualDatacenter.class);
    }

    public VirtualDatacenterDAO(final EntityManager entityManager) {
        super(VirtualDatacenter.class, entityManager);
    }

    private static Criterion sameEnterprise(final Enterprise enterprise) {
        return Restrictions.eq(VirtualDatacenter.ENTERPRISE_PROPERTY, enterprise);
    }

    private static Criterion sameDatacenter(final Datacenter datacenter) {
        return Restrictions.eq(VirtualDatacenter.DATACENTER_PROPERTY, datacenter);
    }

    private static Criterion availableToUser(final User user) {
        Collection<String> idsStrings = Arrays.asList(user.getAvailableVirtualDatacenters().split(","));

        Collection<Integer> ids = CollectionUtils.collect(idsStrings, new Transformer() {
            @Override
            public Object transform(final Object input) {
                return Integer.valueOf(input.toString());
            }
        });

        return Restrictions.in(PersistentEntity.ID_PROPERTY, ids);
    }

    public Collection<VirtualDatacenter> findByEnterpriseAndDatacenter(final Enterprise enterprise,
            final Datacenter datacenter, final User user, final Integer startwith, final Integer limit,
            final String filter, final OrderByEnum orderByEnum, final Boolean asc) {
        Collection<Criterion> restrictions = new ArrayList<Criterion>();
        if (enterprise != null) {
            restrictions.add(sameEnterprise(enterprise));
        }
        if (datacenter != null) {
            restrictions.add(sameDatacenter(datacenter));
        }
        if (user != null) {
            restrictions.add(availableToUser(user));
        }

        return findVirtualDatacentersByCriterions(restrictions, null);
    }

    public Collection<VirtualDatacenter> findByDatacenter(final Datacenter datacenter, final Integer startwith,
            final Integer limit, final String filter, final OrderByEnum orderByEnum, final Boolean asc) {
        Collection<Criterion> restrictions = new ArrayList<Criterion>();
        if (datacenter != null) {
            restrictions.add(sameDatacenter(datacenter));
        }

        return findVirtualDatacentersByCriterions(restrictions, null);
    }

    public Collection<VirtualDatacenter> findByEnterpriseAndDatacenter(final Enterprise enterprise,
            final Datacenter datacenter, final Integer startwith, final Integer limit, final String filter,
            final OrderByEnum orderByEnum, final Boolean asc) {
        return findByEnterpriseAndDatacenter(enterprise, datacenter, null, startwith, limit, filter, orderByEnum,
                asc);
    }

    public Collection<VirtualDatacenter> findByEnterpriseAndDatacenterFilter(final Enterprise enterprise,
            final Datacenter datacenter, final FilterOptions filterOptions) {
        return findByEnterpriseAndDatacenterFilter(enterprise, datacenter, null, filterOptions);
    }

    public Collection<VirtualDatacenter> findByEnterpriseAndDatacenterFilter(final Enterprise enterprise,
            final Datacenter datacenter, final User user, final FilterOptions filterOptions) {
        Collection<Criterion> restrictions = new ArrayList<Criterion>();
        if (enterprise != null) {
            restrictions.add(sameEnterprise(enterprise));
        }
        if (datacenter != null) {
            restrictions.add(sameDatacenter(datacenter));
        }
        if (user != null) {
            restrictions.add(availableToUser(user));
        }

        if (filterOptions != null) {
            restrictions.add(Restrictions.like(VirtualDatacenter.NAME_PROPERTY, filterOptions.getFilter(),
                    MatchMode.ANYWHERE));
        }

        return findVirtualDatacentersByCriterions(restrictions, filterOptions);
    }

    private Collection<VirtualDatacenter> findVirtualDatacentersByCriterions(final Collection<Criterion> criterions,
            final FilterOptions filterOptions) {
        Criteria criteria = getSession().createCriteria(VirtualDatacenter.class);

        for (Criterion criterion : criterions) {
            criteria.add(criterion);
        }

        criteria.addOrder(Order.asc(VirtualDatacenter.NAME_PROPERTY));

        if (filterOptions != null) {
            Integer size = criteria.list().size();

            criteria.setFirstResult(filterOptions.getStartwith());
            criteria.setMaxResults(filterOptions.getLimit());

            PagedList<VirtualDatacenter> vdcList = new PagedList<VirtualDatacenter>(criteria.list());
            vdcList.setTotalResults(size);
            vdcList.setPageSize(filterOptions.getLimit() > size ? size : filterOptions.getLimit());
            vdcList.setCurrentElement(filterOptions.getStartwith());

            return vdcList;
        } else {
            return getResultList(criteria);
        }
    }

    private Criteria createCriteria(final Collection<Criterion> criterions, final String filter,
            final OrderByEnum orderByEnum, final boolean asc) {
        Criteria criteria = getSession().createCriteria(VirtualDatacenter.class);

        for (Criterion criterion : criterions) {
            criteria.add(criterion);
        }

        if (!StringUtils.isEmpty(filter)) {
            criteria.add(filterBy(filter));
        }

        if (!StringUtils.isEmpty(orderByEnum.getColumnSQL())) {
            Order order = Order.desc(orderByEnum.getColumnSQL());
            if (asc) {
                order = Order.asc(orderByEnum.getColumnSQL());
            }
            criteria.addOrder(order);
        }
        return criteria;
    }

    private Criterion filterBy(final String filter) {
        Disjunction filterDisjunction = Restrictions.disjunction();

        filterDisjunction.add(Restrictions.like(VirtualDatacenter.NAME_PROPERTY, '%' + filter + '%'));

        return filterDisjunction;
    }

    public Collection<VirtualDatacenter> findByEnterprise(final Enterprise enterprise) {
        assert enterprise != null;
        assert isManaged2(enterprise);

        Criteria criteria = createCriteria(sameEnterprise(enterprise));
        criteria.addOrder(Order.asc(VirtualDatacenter.NAME_PROPERTY));
        List<VirtualDatacenter> result = getResultList(criteria);
        return result;
    }

    private static final String SUM_VM_RESOURCES = "select sum(vm.cpu), sum(vm.ram), sum(vm.hd) from virtualmachine vm, nodevirtualimage vi, node n, virtualapp a "
            + "where vi.idVM = vm.idVM and vi.idNode = n.idNode and n.idVirtualApp = a.idVirtualApp "
            + "and a.idVirtualDataCenter = :virtualDatacenterId and vm.state != 'NOT_ALLOCATED' and vm.idHypervisor is not null";

    // +
    // "and hy.id = vm.idHypervisor and pm.idPhysicalMachine = hy.idPhysicalMachine and pm.idState != 7";
    // // not HA_DISABLED

    private static final String SUM_VOLUMES_RESOURCES = "select sum(r.limitResource) from rasd r, rasd_management rm where r.instanceID = rm.idResource "
            + "and rm.idResourceType = '8' and rm.idVirtualDatacenter = :virtualDatacenterId";

    private static final String SUM_EXTRA_HD_RESOURCES = "select sum(r.limitResource) from rasd r, rasd_management rm, virtualmachine vm where r.instanceID = rm.idResource "
            + "and rm.idResourceType = '17' and rm.idVirtualDatacenter = :virtualDatacenterId "
            + "and  rm.idVM = vm.idVM and vm.state != 'NOT_ALLOCATED' and vm.idHypervisor is not null";

    private static final String COUNT_PUBLIC_IP_RESOURCES = "select count(*) from ip_pool_management ipm, rasd_management rm, vlan_network vn, virtualdatacenter vdc "
            + " where ipm.vlan_network_id = vn.vlan_network_id " + " and rm.idManagement = ipm.idManagement "
            + " and rm.idVirtualDataCenter = vdc.idVirtualDataCenter "
            + " and vdc.idVirtualDataCenter = :virtualDatacenterId " + " and vn.networktype = 'PUBLIC' ";

    private static final String COUNT_PRIVATE_VLANS_RESOURCES = " SELECT vlan "//
            + "FROM com.abiquo.server.core.infrastructure.network.VLANNetwork vlan, "//
            + "com.abiquo.server.core.cloud.VirtualDatacenter vdc "//
            + "WHERE vlan.network.id = vdc.network.id "//
            + "and vdc.id = :virtualDatacenterId";

    private static final String GET_VDC_FROM_DEFAULT_VLAN = " SELECT vdc "//
            + "FROM VirtualDatacenter vdc "//
            + "WHERE vdc.defaultVlan.id = :vlanId "//
            + "and vdc.defaultVlan.type = 'EXTERNAL'";

    public DefaultEntityCurrentUsed getCurrentResourcesAllocated(final int virtualDatacenterId) {
        Object[] vmResources = (Object[]) getSession().createSQLQuery(SUM_VM_RESOURCES)
                .setParameter("virtualDatacenterId", virtualDatacenterId).uniqueResult();

        Long cpu = vmResources[0] == null ? 0 : ((BigDecimal) vmResources[0]).longValue();
        Long ram = vmResources[1] == null ? 0 : ((BigDecimal) vmResources[1]).longValue();
        Long hd = vmResources[2] == null ? 0 : ((BigDecimal) vmResources[2]).longValue();

        BigDecimal extraHd = (BigDecimal) getSession().createSQLQuery(SUM_EXTRA_HD_RESOURCES)
                .setParameter("virtualDatacenterId", virtualDatacenterId).uniqueResult();
        Long hdTot = extraHd == null ? hd : hd + extraHd.longValue() * 1024 * 1024;

        BigDecimal storage = (BigDecimal) getSession().createSQLQuery(SUM_VOLUMES_RESOURCES)
                .setParameter("virtualDatacenterId", virtualDatacenterId).uniqueResult();

        BigInteger publicIps = (BigInteger) getSession().createSQLQuery(COUNT_PUBLIC_IP_RESOURCES)
                .setParameter("virtualDatacenterId", virtualDatacenterId).uniqueResult();

        DefaultEntityCurrentUsed used = new DefaultEntityCurrentUsed(cpu.intValue(), ram, hdTot);

        // Storage usage is stored in MB
        used.setStorage(storage == null ? 0 : storage.longValue() * 1024 * 1024);
        used.setPublicIp(publicIps == null ? 0 : publicIps.longValue());
        used.setVlanCount(getVLANUsage(virtualDatacenterId).size());

        return used;
    }

    private List<VLANNetwork> getVLANUsage(final Integer virtualdatacenterId) {
        Query query = getSession().createQuery(COUNT_PRIVATE_VLANS_RESOURCES);
        query.setParameter("virtualDatacenterId", virtualdatacenterId);

        return query.list();
    }

    public List<VirtualDatacenter> getVirualDatacenterFromDefaultVlan(final Integer defaultVlanId) {
        Query query = getSession().createQuery(GET_VDC_FROM_DEFAULT_VLAN);
        query.setParameter("vlanId", defaultVlanId);

        return query.list();
    }
}