/**
* 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.storage;
import java.util.List;
import javax.persistence.EntityManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.abiquo.server.core.appslibrary.VirtualMachineTemplate;
import com.abiquo.server.core.cloud.NodeVirtualImage;
import com.abiquo.server.core.cloud.NodeVirtualImageDAO;
import com.abiquo.server.core.cloud.VirtualAppliance;
import com.abiquo.server.core.cloud.VirtualDatacenter;
import com.abiquo.server.core.cloud.VirtualMachine;
import com.abiquo.server.core.common.DefaultRepBase;
import com.abiquo.server.core.enterprise.Enterprise;
import com.abiquo.server.core.enterprise.User;
import com.abiquo.server.core.infrastructure.management.Rasd;
import com.abiquo.server.core.infrastructure.management.RasdDAO;
import com.abiquo.server.core.infrastructure.management.RasdManagement;
import com.abiquo.server.core.infrastructure.management.RasdManagementDAO;
import com.abiquo.server.core.util.FilterOptions;
/**
* @author jdevesa
*/
@Repository
public class StorageRep extends DefaultRepBase
{
@Autowired
private StorageDeviceDAO deviceDAO;
@Autowired
private DiskManagementDAO diskManagementDAO;
@Autowired
private DvdManagementDAO dvdManagementDAO;
@Autowired
private InitiatorMappingDAO initiatorMappingDAO;
@Autowired
private NodeVirtualImageDAO nodeVirtualImageDAO;
@Autowired
private StoragePoolDAO poolDAO;
@Autowired
private RasdDAO rasdDAO;
@Autowired
private RasdManagementDAO rasdManagementDAO;
@Autowired
private TierDAO tierDAO;
@Autowired
private VolumeManagementDAO volumeDAO;
public StorageRep()
{
}
public StorageRep(final EntityManager entityManager)
{
this.deviceDAO = new StorageDeviceDAO(entityManager);
this.diskManagementDAO = new DiskManagementDAO(entityManager);
this.initiatorMappingDAO = new InitiatorMappingDAO(entityManager);
this.nodeVirtualImageDAO = new NodeVirtualImageDAO(entityManager);
this.poolDAO = new StoragePoolDAO(entityManager);
this.rasdDAO = new RasdDAO(entityManager);
this.rasdManagementDAO = new RasdManagementDAO(entityManager);
this.tierDAO = new TierDAO(entityManager);
this.volumeDAO = new VolumeManagementDAO(entityManager);
}
public void deleteDvd(final DvdManagement dvd)
{
dvdManagementDAO.remove(dvd);
}
public List<StoragePool> findAllPools()
{
return poolDAO.findAll();
}
public InitiatorMapping findByVolumeAndInitiator(final Integer idVolumeManagement,
final String initiatorIqn)
{
return initiatorMappingDAO.findByVolumeAndInitiator(idVolumeManagement, initiatorIqn);
}
public void removeInitiatorMappingsForInitiatorIqn(final String initiatorIqn)
{
initiatorMappingDAO.deleteMappingsForInitiator(initiatorIqn);
}
public List<InitiatorMapping> findMapingsByInitiator(final String initiatorIqn)
{
return initiatorMappingDAO.findByInitiatorIqn(initiatorIqn);
}
public StorageDevice findDeviceById(final Integer deviceId)
{
return deviceDAO.findById(deviceId);
}
public StorageDevice findDeviceById(final Integer datacenterId, final Integer deviceId)
{
return deviceDAO.getDeviceById(datacenterId, deviceId);
}
public StorageDevice findDeviceByManagementIP(final Integer datacenterId,
final String managementIp)
{
return deviceDAO.findDeviceByManagementIP(datacenterId, managementIp);
}
public List< ? extends RasdManagement> findDisksAndVolumesByVirtualMachine(
final VirtualMachine vm)
{
return rasdManagementDAO.findDisksAndVolumesByVirtualMachine(vm);
}
public DvdManagement findDvdById(final Integer dvdId)
{
return dvdManagementDAO.findById(dvdId);
}
public DiskManagement findHardDiskByVirtualMachine(final VirtualMachine vm, final Integer diskId)
{
return diskManagementDAO.findHardDiskByVirtualMachine(vm, diskId);
}
public List<DiskManagement> findHardDisksByVirtualMachine(final VirtualMachine vm)
{
return diskManagementDAO.findHardDisksByVirtualMachine(vm);
}
public List<NodeVirtualImage> findNodeVirtualImageByVirtualImage(
final VirtualMachineTemplate virtualImage)
{
return nodeVirtualImageDAO.findByVirtualImage(virtualImage);
}
public StoragePool findPoolById(final String poolId)
{
return poolDAO.findById(poolId);
}
public StoragePool findPoolById(final Integer deviceId, final String poolId)
{
return poolDAO.findPoolById(deviceId, poolId);
}
public StoragePool findPoolByName(final Integer deviceId, final String name)
{
return poolDAO.findPoolByName(deviceId, name);
}
public List<StoragePool> findPoolsByTier(final Tier tier)
{
return poolDAO.findPoolsByTier(tier);
}
public Tier findTierById(final Integer tierId)
{
return tierDAO.findById(tierId);
}
public Tier findTierById(final Integer datacenterId, final Integer tierId)
{
return tierDAO.getTierById(datacenterId, tierId);
}
public VolumeManagement findVolumeById(final Integer volumeId)
{
return volumeDAO.findById(volumeId);
}
public VolumeManagement findVolumeByRasd(final Rasd rasd)
{
return volumeDAO.getVolumeByRasd(rasd);
}
public List<VolumeManagement> findVolumesByEnterprise(final Enterprise enterprise,
final User currentUser, final FilterOptions filters, final boolean includePersistent)
{
return volumeDAO
.getVolumesByEnterprise(enterprise, currentUser, filters, includePersistent);
}
public List<VolumeManagement> findVolumesByPool(final StoragePool pool,
final FilterOptions filters)
{
return volumeDAO.getVolumesByPool(pool, filters);
}
public List<Tier> getAllTiers()
{
return tierDAO.findAll();
}
public List<VolumeManagement> getAttachedVolumes(final VirtualDatacenter vdc)
{
return volumeDAO.getAttachedVolumes(vdc);
}
public List<VolumeManagement> getAvailableVolumes(final VirtualDatacenter vdc,
final FilterOptions filterOptions)
{
return volumeDAO.getAvailableVolumes(vdc, filterOptions);
}
public List<VolumeManagement> getDetachedVolumes(final VirtualDatacenter vdc)
{
return volumeDAO.getDetachedVolumes(vdc);
}
public List<StorageDevice> getDevicesByDatacenter(final Integer datacenterId)
{
return deviceDAO.getDevicesByDatacenter(datacenterId);
}
public List<Tier> getEnableTiersByDatacenter(final Integer datacenterId)
{
return tierDAO.getEnableTiersByDatacenter(datacenterId);
}
public InitiatorMapping getInitiatorMapping(final Integer mappingId)
{
return initiatorMappingDAO.findById(mappingId);
}
public List<InitiatorMapping> getInitiatorMappings(final Integer idVolume)
{
return initiatorMappingDAO.findByVolumeId(idVolume);
}
public List<StoragePool> getPoolsByDevice(final Integer deviceId)
{
return poolDAO.getPoolsByStorageDevice(deviceId);
}
public List<VolumeManagement> getStatefulCandidates(final VirtualDatacenter vdc)
{
return volumeDAO.getStatefulCandidates(vdc);
}
public List<Tier> getTiersByDatacenter(final Integer datacenterId)
{
return tierDAO.getTiersByDatacenter(datacenterId);
}
public VolumeManagement getVolumeByVirtualDatacenter(final VirtualDatacenter vdc,
final Integer volumeId)
{
return volumeDAO.getVolumeByVirtualDatacenter(vdc, volumeId);
}
public VolumeManagement getVolumeFromImage(final Integer idImage)
{
return volumeDAO.getVolumeFromImage(idImage);
}
public List<VolumeManagement> getVolumesByPool(final StoragePool pool)
{
return volumeDAO.getVolumesByPool(pool);
}
public List<VolumeManagement> getVolumesByVirtualAppliance(final VirtualAppliance vapp)
{
return volumeDAO.getVolumesByVirtualAppliance(vapp);
}
public List<VolumeManagement> getVolumesByVirtualDatacenter(final VirtualDatacenter vdc,
final FilterOptions filterOptions, final boolean includePersistent)
{
return volumeDAO.getVolumesByVirtualDatacenter(vdc, filterOptions, includePersistent);
}
public List<VolumeManagement> getVolumesByVirtualMachine(final VirtualMachine vm,
final FilterOptions filters)
{
return volumeDAO.getVolumesByVirtualMachine(vm, filters);
}
public StorageDevice insertDevice(final StorageDevice sd)
{
deviceDAO.persist(sd);
deviceDAO.flush();
return sd;
}
public void insertDVD(final DvdManagement dvd)
{
// rasdDAO.persist(dvd.getRasd());
dvdManagementDAO.persist(dvd);
}
public void insertHardDisk(final DiskManagement createdDisk)
{
if (createdDisk.getRasd() != null)
{
rasdDAO.persist(createdDisk.getRasd());
}
diskManagementDAO.persist(createdDisk);
}
public void insertInitiatorMapping(final InitiatorMapping imapping)
{
initiatorMappingDAO.persist(imapping);
}
public StoragePool insertPool(final StoragePool sp)
{
poolDAO.persist(sp);
poolDAO.flush();
return sp;
}
public void insertTemporalDVD(final DvdManagement dvd)
{
dvdManagementDAO.persist(dvd);
}
/** Temporal backup rasd_management uses the same rasd */
public void insertTemporalHardDisk(final DiskManagement createdDisk)
{
diskManagementDAO.persist(createdDisk);
}
/** Temporal backup rasd_management uses the same rasd */
public VolumeManagement insertTemporalVolume(final VolumeManagement volume)
{
volumeDAO.persist(volume);
return volume;
}
public Tier insertTier(final Tier tier)
{
tierDAO.persist(tier);
tierDAO.flush();
return tier;
}
public VolumeManagement insertVolume(final VolumeManagement volume)
{
rasdDAO.persist(volume.getRasd());
volumeDAO.persist(volume);
volumeDAO.flush();
return volume;
}
public void removeDevice(final StorageDevice sd)
{
deviceDAO.remove(sd);
deviceDAO.flush();
}
public void removeHardDisk(final DiskManagement diskToDelete)
{
Rasd rasd = diskToDelete.getRasd();
diskManagementDAO.remove(diskToDelete);
rasdDAO.remove(rasd);
diskManagementDAO.flush();
}
public void removePool(final StoragePool sp)
{
poolDAO.remove(sp);
poolDAO.flush();
}
public void removeVolume(final VolumeManagement volume)
{
Rasd rasd = volume.getRasd();
volumeDAO.remove(volume);
rasdDAO.remove(rasd);
volumeDAO.flush();
}
public void updateDevice(final StorageDevice sd)
{
deviceDAO.flush();
}
public void updatePool(final StoragePool pool)
{
poolDAO.flush();
}
public void updateTier(final Tier tier)
{
tierDAO.flush();
}
public void updateVolume(final VolumeManagement volume)
{
volumeDAO.flush();
}
public InitiatorMapping findBPMMappingForVolume(final Integer volumeId, final String bpmAddress)
{
return initiatorMappingDAO.findBPMMappingForVolume(volumeId, bpmAddress);
}
public boolean existVolumesInTheTierByEnterprise(final Integer enterpriseId,
final Integer tierId)
{
return !volumeDAO.getVolumesInTheTierByEnterprise(enterpriseId, tierId).isEmpty();
}
}