private static final Logger s_logger = Logger.getLogger(StorageManagerImpl.class);

protected String _name;

@Inject

protected AgentManager _agentMgr;

@Inject

protected TemplateManager _tmpltMgr;

@Inject

protected AccountManager _accountMgr;

@Inject

protected ConfigurationManager _configMgr;

@Inject

protected VolumeDao _volsDao;

@Inject

protected HostDao _hostDao;

@Inject

protected SnapshotDao _snapshotDao;

@Inject

protected StoragePoolHostDao _storagePoolHostDao;

@Inject

protected VMTemplatePoolDao _vmTemplatePoolDao = null;

@Inject

protected VMTemplateZoneDao _vmTemplateZoneDao;

@Inject

protected VMTemplateDao _vmTemplateDao = null;

@Inject

protected VMInstanceDao _vmInstanceDao;

@Inject

protected PrimaryDataStoreDao _storagePoolDao = null;

@Inject

protected StoragePoolDetailsDao _storagePoolDetailsDao;

@Inject

protected ImageStoreDao _imageStoreDao = null;

@Inject

protected ImageStoreDetailsDao _imageStoreDetailsDao = null;

@Inject

protected SnapshotDataStoreDao _snapshotStoreDao = null;

@Inject

protected TemplateDataStoreDao _templateStoreDao = null;

@Inject

protected TemplateJoinDao _templateViewDao = null;

@Inject

protected VolumeDataStoreDao _volumeStoreDao = null;

@Inject

protected CapacityDao _capacityDao;

@Inject

protected CapacityManager _capacityMgr;

@Inject

protected DataCenterDao _dcDao = null;

@Inject

protected VMTemplateDao _templateDao;

@Inject

protected UserDao _userDao;

@Inject

protected ClusterDao _clusterDao;

@Inject

protected StoragePoolWorkDao _storagePoolWorkDao;

@Inject

protected HypervisorGuruManager _hvGuruMgr;

@Inject

protected VolumeDao _volumeDao;

@Inject

ConfigurationDao _configDao;

@Inject

ManagementServer _msServer;

@Inject

DataStoreManager dataStoreMgr;

@Inject

DataStoreProviderManager dataStoreProviderMgr;

@Inject

VolumeService volService;

@Inject

VolumeDataFactory volFactory;

@Inject

TemplateDataFactory tmplFactory;

@Inject

SnapshotDataFactory snapshotFactory;

@Inject

ConfigurationServer _configServer;

@Inject

DataStoreManager _dataStoreMgr;

@Inject

DataStoreProviderManager _dataStoreProviderMgr;

@Inject

private TemplateService _imageSrv;

@Inject

EndPointSelector _epSelector;

protected List<StoragePoolDiscoverer> _discoverers;

public List<StoragePoolDiscoverer> getDiscoverers() {

return _discoverers;

}

public void setDiscoverers(List<StoragePoolDiscoverer> discoverers) {

_discoverers = discoverers;

}

protected SearchBuilder<VMTemplateHostVO> HostTemplateStatesSearch;

protected GenericSearchBuilder<StoragePoolHostVO, Long> UpHostsInPoolSearch;

protected SearchBuilder<VMInstanceVO> StoragePoolSearch;

protected SearchBuilder<StoragePoolVO> LocalStorageSearch;

ScheduledExecutorService _executor = null;

boolean _storageCleanupEnabled;

boolean _templateCleanupEnabled = true;

int _storageCleanupInterval;

int _storagePoolAcquisitionWaitSeconds = 1800; // 30 minutes

int _downloadUrlCleanupInterval;

int _downloadUrlExpirationInterval;

// protected BigDecimal _overProvisioningFactor = new BigDecimal(1);

private long _serverId;

private final Map<String, HypervisorHostListener> hostListeners = new HashMap<String, HypervisorHostListener>();

public boolean share(VMInstanceVO vm, List<VolumeVO> vols, HostVO host, boolean cancelPreviousShare) throws StorageUnavailableException {

// if pool is in maintenance and it is the ONLY pool available; reject

List<VolumeVO> rootVolForGivenVm = _volsDao.findByInstanceAndType(vm.getId(), Type.ROOT);

if (rootVolForGivenVm != null && rootVolForGivenVm.size() > 0) {

boolean isPoolAvailable = isPoolAvailable(rootVolForGivenVm.get(0).getPoolId());

if (!isPoolAvailable) {

throw new StorageUnavailableException("Can not share " + vm, rootVolForGivenVm.get(0).getPoolId());

}

}

// this check is done for maintenance mode for primary storage

// if any one of the volume is unusable, we return false

// if we return false, the allocator will try to switch to another PS if

// available

for (VolumeVO vol : vols) {

if (vol.getRemoved() != null) {

s_logger.warn("Volume id:" + vol.getId() + " is removed, cannot share on this instance");

// not ok to share

return false;

}

}

// ok to share

return true;

}

private boolean isPoolAvailable(Long poolId) {

// get list of all pools

List<StoragePoolVO> pools = _storagePoolDao.listAll();

// if no pools or 1 pool which is in maintenance

if (pools == null || pools.size() == 0 || (pools.size() == 1 && pools.get(0).getStatus().equals(StoragePoolStatus.Maintenance))) {

return false;

} else {

return true;

}

}

@Override

public List<StoragePoolVO> ListByDataCenterHypervisor(long datacenterId, HypervisorType type) {

List<StoragePoolVO> pools = _storagePoolDao.listByDataCenterId(datacenterId);

List<StoragePoolVO> retPools = new ArrayList<StoragePoolVO>();

for (StoragePoolVO pool : pools) {

if (pool.getStatus() != StoragePoolStatus.Up) {

continue;

}

if (pool.getScope() == ScopeType.ZONE) {

if (pool.getHypervisor() != null && pool.getHypervisor() == type) {

retPools.add(pool);

}

} else {

ClusterVO cluster = _clusterDao.findById(pool.getClusterId());

if (type == cluster.getHypervisorType()) {

retPools.add(pool);

}

}

}

Collections.shuffle(retPools);

return retPools;

}

@Override

public boolean isLocalStorageActiveOnHost(Long hostId) {

List<StoragePoolHostVO> storagePoolHostRefs = _storagePoolHostDao.listByHostId(hostId);

for (StoragePoolHostVO storagePoolHostRef : storagePoolHostRefs) {

StoragePoolVO PrimaryDataStoreVO = _storagePoolDao.findById(storagePoolHostRef.getPoolId());

if (PrimaryDataStoreVO.getPoolType() == StoragePoolType.LVM || PrimaryDataStoreVO.getPoolType() == StoragePoolType.EXT) {

SearchBuilder<VolumeVO> volumeSB = _volsDao.createSearchBuilder();

volumeSB.and("poolId", volumeSB.entity().getPoolId(), SearchCriteria.Op.EQ);

volumeSB.and("removed", volumeSB.entity().getRemoved(), SearchCriteria.Op.NULL);

volumeSB.and("state", volumeSB.entity().getState(), SearchCriteria.Op.NIN);

SearchBuilder<VMInstanceVO> activeVmSB = _vmInstanceDao.createSearchBuilder();

activeVmSB.and("state", activeVmSB.entity().getState(), SearchCriteria.Op.IN);

volumeSB.join("activeVmSB", activeVmSB, volumeSB.entity().getInstanceId(), activeVmSB.entity().getId(), JoinBuilder.JoinType.INNER);

SearchCriteria<VolumeVO> volumeSC = volumeSB.create();

volumeSC.setParameters("poolId", PrimaryDataStoreVO.getId());

volumeSC.setParameters("state", Volume.State.Expunging, Volume.State.Destroy);

volumeSC.setJoinParameters("activeVmSB", "state", State.Starting, State.Running, State.Stopping, State.Migrating);

List<VolumeVO> volumes = _volsDao.search(volumeSC, null);

if (volumes.size() > 0) {

return true;

}

}

}

return false;

}

@Override

public Answer[] sendToPool(StoragePool pool, Commands cmds) throws StorageUnavailableException {

return sendToPool(pool, null, null, cmds).second();

}

@Override

public Answer sendToPool(StoragePool pool, long[] hostIdsToTryFirst, Command cmd) throws StorageUnavailableException {

Answer[] answers = sendToPool(pool, hostIdsToTryFirst, null, new Commands(cmd)).second();

if (answers == null) {

return null;

}

return answers[0];

}

@Override

public Answer sendToPool(StoragePool pool, Command cmd) throws StorageUnavailableException {

Answer[] answers = sendToPool(pool, new Commands(cmd));

if (answers == null) {

return null;

}

return answers[0];

}

public Long chooseHostForStoragePool(StoragePoolVO poolVO, List<Long> avoidHosts, boolean sendToVmResidesOn, Long vmId) {

if (sendToVmResidesOn) {

if (vmId != null) {

VMInstanceVO vmInstance = _vmInstanceDao.findById(vmId);

if (vmInstance != null) {

Long hostId = vmInstance.getHostId();

if (hostId != null && !avoidHosts.contains(vmInstance.getHostId())) {

return hostId;

}

}

}

/*

}

List<StoragePoolHostVO> poolHosts = _storagePoolHostDao.listByHostStatus(poolVO.getId(), Status.Up);

Collections.shuffle(poolHosts);

if (poolHosts != null && poolHosts.size() > 0) {

for (StoragePoolHostVO sphvo : poolHosts) {

if (!avoidHosts.contains(sphvo.getHostId())) {

return sphvo.getHostId();

}

}

}

return null;

}

@Override

public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {

Map<String, String> configs = _configDao.getConfiguration("management-server", params);

_storagePoolAcquisitionWaitSeconds = NumbersUtil.parseInt(configs.get("pool.acquisition.wait.seconds"), 1800);

s_logger.info("pool.acquisition.wait.seconds is configured as " + _storagePoolAcquisitionWaitSeconds + " seconds");

_agentMgr.registerForHostEvents(new StoragePoolMonitor(this, _storagePoolDao), true, false, true);

String storageCleanupEnabled = configs.get("storage.cleanup.enabled");

_storageCleanupEnabled = (storageCleanupEnabled == null) ? true : Boolean.parseBoolean(storageCleanupEnabled);

String value = _configDao.getValue(Config.StorageTemplateCleanupEnabled.key());

_templateCleanupEnabled = (value == null ? true : Boolean.parseBoolean(value));

String time = configs.get("storage.cleanup.interval");

_storageCleanupInterval = NumbersUtil.parseInt(time, 86400);

s_logger.info("Storage cleanup enabled: " + _storageCleanupEnabled + ", interval: " + _storageCleanupInterval + ", template cleanup enabled: " +

_templateCleanupEnabled);

String cleanupInterval = configs.get("extract.url.cleanup.interval");

_downloadUrlCleanupInterval = NumbersUtil.parseInt(cleanupInterval, 7200);

String urlExpirationInterval = configs.get("extract.url.expiration.interval");

_downloadUrlExpirationInterval = NumbersUtil.parseInt(urlExpirationInterval, 14400);

String workers = configs.get("expunge.workers");

int wrks = NumbersUtil.parseInt(workers, 10);

_executor = Executors.newScheduledThreadPool(wrks, new NamedThreadFactory("StorageManager-Scavenger"));

_agentMgr.registerForHostEvents(ComponentContext.inject(LocalStoragePoolListener.class), true, false, false);

_serverId = _msServer.getId();

UpHostsInPoolSearch = _storagePoolHostDao.createSearchBuilder(Long.class);

UpHostsInPoolSearch.selectFields(UpHostsInPoolSearch.entity().getHostId());

SearchBuilder<HostVO> hostSearch = _hostDao.createSearchBuilder();

hostSearch.and("status", hostSearch.entity().getStatus(), Op.EQ);

hostSearch.and("resourceState", hostSearch.entity().getResourceState(), Op.EQ);

UpHostsInPoolSearch.join("hosts", hostSearch, hostSearch.entity().getId(), UpHostsInPoolSearch.entity().getHostId(), JoinType.INNER);

UpHostsInPoolSearch.and("pool", UpHostsInPoolSearch.entity().getPoolId(), Op.EQ);

UpHostsInPoolSearch.done();

StoragePoolSearch = _vmInstanceDao.createSearchBuilder();

SearchBuilder<VolumeVO> volumeSearch = _volumeDao.createSearchBuilder();

volumeSearch.and("volumeType", volumeSearch.entity().getVolumeType(), SearchCriteria.Op.EQ);

volumeSearch.and("poolId", volumeSearch.entity().getPoolId(), SearchCriteria.Op.EQ);

volumeSearch.and("state", volumeSearch.entity().getState(), SearchCriteria.Op.EQ);

StoragePoolSearch.join("vmVolume", volumeSearch, volumeSearch.entity().getInstanceId(), StoragePoolSearch.entity().getId(), JoinBuilder.JoinType.INNER);

StoragePoolSearch.done();

LocalStorageSearch = _storagePoolDao.createSearchBuilder();

SearchBuilder<StoragePoolHostVO> storageHostSearch = _storagePoolHostDao.createSearchBuilder();

storageHostSearch.and("hostId", storageHostSearch.entity().getHostId(), SearchCriteria.Op.EQ);

LocalStorageSearch.join("poolHost", storageHostSearch, storageHostSearch.entity().getPoolId(), LocalStorageSearch.entity().getId(), JoinBuilder.JoinType.INNER);

LocalStorageSearch.and("type", LocalStorageSearch.entity().getPoolType(), SearchCriteria.Op.IN);

LocalStorageSearch.done();

Volume.State.getStateMachine().registerListener(new VolumeStateListener(_configDao, _vmInstanceDao));

return true;

}

@Override

public String getStoragePoolTags(long poolId) {

return StringUtils.listToCsvTags(_storagePoolDao.searchForStoragePoolDetails(poolId, "true"));

}

@Override

public boolean start() {

if (_storageCleanupEnabled) {

Random generator = new Random();

int initialDelay = generator.nextInt(_storageCleanupInterval);

_executor.scheduleWithFixedDelay(new StorageGarbageCollector(), initialDelay, _storageCleanupInterval, TimeUnit.SECONDS);

} else {

s_logger.debug("Storage cleanup is not enabled, so the storage cleanup thread is not being scheduled.");

}

_executor.scheduleWithFixedDelay(new DownloadURLGarbageCollector(), _downloadUrlCleanupInterval, _downloadUrlCleanupInterval, TimeUnit.SECONDS);

return true;

}

@Override

public boolean stop() {

if (_storageCleanupEnabled) {

_executor.shutdown();

}

return true;

}

@DB

@Override

public DataStore createLocalStorage(Host host, StoragePoolInfo pInfo) throws ConnectionException {

DataCenterVO dc = _dcDao.findById(host.getDataCenterId());

if (dc == null) {

return null;

}

boolean useLocalStorageForSystemVM = false;

Boolean isLocal = ConfigurationManagerImpl.SystemVMUseLocalStorage.valueIn(dc.getId());

if (isLocal != null) {

useLocalStorageForSystemVM = isLocal.booleanValue();

}

if (!(dc.isLocalStorageEnabled() || useLocalStorageForSystemVM)) {

return null;

}

DataStore store;

try {

String hostAddress = pInfo.getHost();

if (host.getHypervisorType() == Hypervisor.HypervisorType.VMware) {

hostAddress = "VMFS datastore: " + pInfo.getHostPath();

}

StoragePoolVO pool = _storagePoolDao.findPoolByHostPath(host.getDataCenterId(), host.getPodId(), hostAddress, pInfo.getHostPath(), pInfo.getUuid());

if (pool == null && host.getHypervisorType() == HypervisorType.VMware) {

// perform run-time upgrade. In versions prior to 2.2.12, there

// is a bug that we don't save local datastore info (host path

// is empty), this will cause us

// not able to distinguish multiple local datastores that may be

// available on the host, to support smooth migration, we

// need to perform runtime upgrade here

if (pInfo.getHostPath().length() > 0) {

pool = _storagePoolDao.findPoolByHostPath(host.getDataCenterId(), host.getPodId(), hostAddress, "", pInfo.getUuid());

}

}

if (pool == null) {

//the path can be different, but if they have the same uuid, assume they are the same storage

pool = _storagePoolDao.findPoolByHostPath(host.getDataCenterId(), host.getPodId(), hostAddress, null,

pInfo.getUuid());

if (pool != null) {

s_logger.debug("Found a storage pool: " + pInfo.getUuid() + ", but with different hostpath " + pInfo.getHostPath() + ", still treat it as the same pool");

}

}

DataStoreProvider provider = dataStoreProviderMgr.getDefaultPrimaryDataStoreProvider();

DataStoreLifeCycle lifeCycle = provider.getDataStoreLifeCycle();

if (pool == null) {

Map<String, Object> params = new HashMap<String, Object>();

String name = (host.getName() + " Local Storage");

params.put("zoneId", host.getDataCenterId());

params.put("clusterId", host.getClusterId());

params.put("podId", host.getPodId());

params.put("url", pInfo.getPoolType().toString() + "://" + pInfo.getHost() + "/" + pInfo.getHostPath());

params.put("name", name);

params.put("localStorage", true);

params.put("details", pInfo.getDetails());

params.put("uuid", pInfo.getUuid());

params.put("providerName", provider.getName());

store = lifeCycle.initialize(params);

} else {

store = dataStoreMgr.getDataStore(pool.getId(), DataStoreRole.Primary);

}

pool = _storagePoolDao.findById(store.getId());

if (pool.getStatus() != StoragePoolStatus.Maintenance && pool.getStatus() != StoragePoolStatus.Removed) {

HostScope scope = new HostScope(host.getId(), host.getClusterId(), host.getDataCenterId());

lifeCycle.attachHost(store, scope, pInfo);

}

} catch (Exception e) {

s_logger.warn("Unable to setup the local storage pool for " + host, e);

throw new ConnectionException(true, "Unable to setup the local storage pool for " + host, e);

}

return dataStoreMgr.getDataStore(store.getId(), DataStoreRole.Primary);

}

@Override

public PrimaryDataStoreInfo createPool(CreateStoragePoolCmd cmd) throws ResourceInUseException, IllegalArgumentException, UnknownHostException,

ResourceUnavailableException {

String providerName = cmd.getStorageProviderName();

DataStoreProvider storeProvider = dataStoreProviderMgr.getDataStoreProvider(providerName);

if (storeProvider == null) {

storeProvider = dataStoreProviderMgr.getDefaultPrimaryDataStoreProvider();

if (storeProvider == null) {

throw new InvalidParameterValueException("can't find storage provider: " + providerName);

}

}

Long clusterId = cmd.getClusterId();

Long podId = cmd.getPodId();

Long zoneId = cmd.getZoneId();

ScopeType scopeType = ScopeType.CLUSTER;

String scope = cmd.getScope();

if (scope != null) {

try {

scopeType = Enum.valueOf(ScopeType.class, scope.toUpperCase());

} catch (Exception e) {

throw new InvalidParameterValueException("invalid scope for pool " + scope);

}

}

if (scopeType == ScopeType.CLUSTER && clusterId == null) {

throw new InvalidParameterValueException("cluster id can't be null, if scope is cluster");

} else if (scopeType == ScopeType.ZONE && zoneId == null) {

throw new InvalidParameterValueException("zone id can't be null, if scope is zone");

}

HypervisorType hypervisorType = HypervisorType.KVM;

if (scopeType == ScopeType.ZONE) {

// ignore passed clusterId and podId

clusterId = null;

podId = null;

String hypervisor = cmd.getHypervisor();

if (hypervisor != null) {

try {

hypervisorType = HypervisorType.getType(hypervisor);

} catch (Exception e) {

throw new InvalidParameterValueException("invalid hypervisor type " + hypervisor);

}

} else {

throw new InvalidParameterValueException("Missing parameter hypervisor. Hypervisor type is required to create zone wide primary storage.");

}

if (hypervisorType != HypervisorType.KVM && hypervisorType != HypervisorType.VMware && hypervisorType != HypervisorType.Hyperv && hypervisorType != HypervisorType.LXC && hypervisorType != HypervisorType.Any) {

throw new InvalidParameterValueException("zone wide storage pool is not supported for hypervisor type " + hypervisor);

}

}

Map<String, String> details = extractApiParamAsMap(cmd.getDetails());

DataCenterVO zone = _dcDao.findById(cmd.getZoneId());

if (zone == null) {

throw new InvalidParameterValueException("unable to find zone by id " + zoneId);

}

// Check if zone is disabled

Account account = CallContext.current().getCallingAccount();

if (Grouping.AllocationState.Disabled == zone.getAllocationState() && !_accountMgr.isRootAdmin(account.getId())) {

throw new PermissionDeniedException("Cannot perform this operation, Zone is currently disabled: " + zoneId);

}

Map<String, Object> params = new HashMap<String, Object>();

params.put("zoneId", zone.getId());

params.put("clusterId", clusterId);

params.put("podId", podId);

params.put("url", cmd.getUrl());

params.put("tags", cmd.getTags());

params.put("name", cmd.getStoragePoolName());

params.put("details", details);

params.put("providerName", storeProvider.getName());

params.put("managed", cmd.isManaged());

params.put("capacityBytes", cmd.getCapacityBytes());

params.put("capacityIops", cmd.getCapacityIops());

DataStoreLifeCycle lifeCycle = storeProvider.getDataStoreLifeCycle();

DataStore store = null;

try {

store = lifeCycle.initialize(params);

if (scopeType == ScopeType.CLUSTER) {

ClusterScope clusterScope = new ClusterScope(clusterId, podId, zoneId);

lifeCycle.attachCluster(store, clusterScope);

} else if (scopeType == ScopeType.ZONE) {

ZoneScope zoneScope = new ZoneScope(zoneId);

lifeCycle.attachZone(store, zoneScope, hypervisorType);

}

} catch (Exception e) {

s_logger.debug("Failed to add data store: "+e.getMessage(), e);

try {

// clean up the db, just absorb the exception thrown in deletion with error logged, so that user can get error for adding data store

// not deleting data store.

if (store != null) {

lifeCycle.deleteDataStore(store);

}

} catch (Exception ex) {

s_logger.debug("Failed to clean up storage pool: " + ex.getMessage());

}

throw new CloudRuntimeException("Failed to add data store: "+e.getMessage(), e);

}

return (PrimaryDataStoreInfo)dataStoreMgr.getDataStore(store.getId(), DataStoreRole.Primary);

}

private Map<String, String> extractApiParamAsMap(Map ds) {

Map<String, String> details = new HashMap<String, String>();

if (ds != null) {

Collection detailsCollection = ds.values();

Iterator it = detailsCollection.iterator();

while (it.hasNext()) {

HashMap d = (HashMap)it.next();

Iterator it2 = d.entrySet().iterator();

while (it2.hasNext()) {

Map.Entry entry = (Map.Entry)it2.next();

details.put((String)entry.getKey(), (String)entry.getValue());

}

}

}

return details;

}

@Override

public PrimaryDataStoreInfo updateStoragePool(UpdateStoragePoolCmd cmd) throws IllegalArgumentException {

// Input validation

Long id = cmd.getId();

List<String> tags = cmd.getTags();

StoragePoolVO pool = _storagePoolDao.findById(id);

if (pool == null) {

throw new IllegalArgumentException("Unable to find storage pool with ID: " + id);

}

Map<String, String> updatedDetails = new HashMap<String, String>();

if (tags != null) {

Map<String, String> existingDetails = _storagePoolDetailsDao.listDetailsKeyPairs(id);

Set<String> existingKeys = existingDetails.keySet();

Map<String, String> existingDetailsToKeep = new HashMap<String, String>();

for (String existingKey : existingKeys) {

String existingValue = existingDetails.get(existingKey);

if (!Boolean.TRUE.toString().equalsIgnoreCase(existingValue)) {

existingDetailsToKeep.put(existingKey, existingValue);

}

}

Map<String, String> details = new HashMap<String, String>();

for (String tag : tags) {

tag = tag.trim();

if (tag.length() > 0 && !details.containsKey(tag)) {

details.put(tag, "true");

}

}

Set<String> existingKeysToKeep = existingDetailsToKeep.keySet();

for (String existingKeyToKeep : existingKeysToKeep) {

String existingValueToKeep = existingDetailsToKeep.get(existingKeyToKeep);

if (details.containsKey(existingKeyToKeep)) {

throw new CloudRuntimeException("Storage tag '" + existingKeyToKeep +

"' conflicts with a stored property of this primary storage. No changes were made.");

}

details.put(existingKeyToKeep, existingValueToKeep);

}

updatedDetails.putAll(details);

}

Long updatedCapacityBytes = null;

Long capacityBytes = cmd.getCapacityBytes();

if (capacityBytes != null) {

if (capacityBytes != pool.getCapacityBytes()) {

updatedCapacityBytes = capacityBytes;

}

}

Long updatedCapacityIops = null;

Long capacityIops = cmd.getCapacityIops();

if (capacityIops != null) {

if (!capacityIops.equals(pool.getCapacityIops())) {

updatedCapacityIops = capacityIops;

}

}

if (updatedCapacityBytes != null || updatedCapacityIops != null) {

StoragePoolVO storagePool = _storagePoolDao.findById(id);

DataStoreProvider dataStoreProvider = dataStoreProviderMgr.getDataStoreProvider(storagePool.getStorageProviderName());

DataStoreLifeCycle dataStoreLifeCycle = dataStoreProvider.getDataStoreLifeCycle();

if (dataStoreLifeCycle instanceof PrimaryDataStoreLifeCycle) {

Map<String, String> details = new HashMap<String, String>();

details.put(PrimaryDataStoreLifeCycle.CAPACITY_BYTES, updatedCapacityBytes != null ? String.valueOf(updatedCapacityBytes) : null);

details.put(PrimaryDataStoreLifeCycle.CAPACITY_IOPS, updatedCapacityIops != null ? String.valueOf(updatedCapacityIops) : null);

((PrimaryDataStoreLifeCycle)dataStoreLifeCycle).updateStoragePool(storagePool, details);

}

}

if (updatedDetails.size() >= 0) {

_storagePoolDao.updateDetails(id, updatedDetails);

}

if (updatedCapacityBytes != null) {

_storagePoolDao.updateCapacityBytes(id, capacityBytes);

}

if (updatedCapacityIops != null) {

_storagePoolDao.updateCapacityIops(id, capacityIops);

}

return (PrimaryDataStoreInfo)dataStoreMgr.getDataStore(pool.getId(), DataStoreRole.Primary);

}

@Override

@DB

public boolean deletePool(DeletePoolCmd cmd) {

Long id = cmd.getId();

boolean forced = cmd.isForced();

StoragePoolVO sPool = _storagePoolDao.findById(id);

if (sPool == null) {

s_logger.warn("Unable to find pool:" + id);

throw new InvalidParameterValueException("Unable to find pool by id " + id);

}

if (sPool.getStatus() != StoragePoolStatus.Maintenance) {

s_logger.warn("Unable to delete storage id: " + id + " due to it is not in Maintenance state");

throw new InvalidParameterValueException("Unable to delete storage due to it is not in Maintenance state, id: " + id);

}

if (sPool.isLocal()) {

s_logger.warn("Unable to delete local storage id:" + id);

throw new InvalidParameterValueException("Unable to delete local storage id: " + id);

}

Pair<Long, Long> vlms = _volsDao.getCountAndTotalByPool(id);

if (forced) {

if (vlms.first() > 0) {

Pair<Long, Long> nonDstrdVlms = _volsDao.getNonDestroyedCountAndTotalByPool(id);

if (nonDstrdVlms.first() > 0) {

throw new CloudRuntimeException("Cannot delete pool " + sPool.getName() + " as there are associated " + "non-destroyed vols for this pool");

}

// force expunge non-destroyed volumes

List<VolumeVO> vols = _volsDao.listVolumesToBeDestroyed();

for (VolumeVO vol : vols) {

AsyncCallFuture<VolumeApiResult> future = volService.expungeVolumeAsync(volFactory.getVolume(vol.getId()));

try {

future.get();

} catch (InterruptedException e) {

s_logger.debug("expunge volume failed:" + vol.getId(), e);

} catch (ExecutionException e) {

s_logger.debug("expunge volume failed:" + vol.getId(), e);

}

}

}

} else {

// Check if the pool has associated volumes in the volumes table

// If it does , then you cannot delete the pool

if (vlms.first() > 0) {

throw new CloudRuntimeException("Cannot delete pool " + sPool.getName() + " as there are associated volumes for this pool");

}

}

// First get the host_id from storage_pool_host_ref for given pool id

StoragePoolVO lock = _storagePoolDao.acquireInLockTable(sPool.getId());

if (lock == null) {

if (s_logger.isDebugEnabled()) {

s_logger.debug("Failed to acquire lock when deleting PrimaryDataStoreVO with ID: " + sPool.getId());

}

return false;

}

_storagePoolDao.releaseFromLockTable(lock.getId());

s_logger.trace("Released lock for storage pool " + id);

DataStoreProvider storeProvider = dataStoreProviderMgr.getDataStoreProvider(sPool.getStorageProviderName());

DataStoreLifeCycle lifeCycle = storeProvider.getDataStoreLifeCycle();

DataStore store = dataStoreMgr.getDataStore(sPool.getId(), DataStoreRole.Primary);

return lifeCycle.deleteDataStore(store);

}

@Override

public void connectHostToSharedPool(long hostId, long poolId) throws StorageUnavailableException {

StoragePool pool = (StoragePool)dataStoreMgr.getDataStore(poolId, DataStoreRole.Primary);

assert (pool.isShared()) : "Now, did you actually read the name of this method?";

s_logger.debug("Adding pool " + pool.getName() + " to host " + hostId);

DataStoreProvider provider = dataStoreProviderMgr.getDataStoreProvider(pool.getStorageProviderName());

HypervisorHostListener listener = hostListeners.get(provider.getName());

listener.hostConnect(hostId, pool.getId());

}

@Override

public BigDecimal getStorageOverProvisioningFactor(Long poolId) {

return new BigDecimal(CapacityManager.StorageOverprovisioningFactor.valueIn(poolId));

}

@Override

public void createCapacityEntry(StoragePoolVO storagePool, short capacityType, long allocated) {

SearchCriteria<CapacityVO> capacitySC = _capacityDao.createSearchCriteria();

capacitySC.addAnd("hostOrPoolId", SearchCriteria.Op.EQ, storagePool.getId());

capacitySC.addAnd("dataCenterId", SearchCriteria.Op.EQ, storagePool.getDataCenterId());

capacitySC.addAnd("capacityType", SearchCriteria.Op.EQ, capacityType);

List<CapacityVO> capacities = _capacityDao.search(capacitySC, null);

long totalOverProvCapacity;

if (storagePool.getPoolType() == StoragePoolType.NetworkFilesystem || storagePool.getPoolType() == StoragePoolType.VMFS) {

// All this is for the inaccuracy of floats for big number multiplication.

BigDecimal overProvFactor = getStorageOverProvisioningFactor(storagePool.getId());

totalOverProvCapacity = overProvFactor.multiply(new BigDecimal(storagePool.getCapacityBytes())).longValue();

s_logger.debug("Found storage pool " + storagePool.getName() + " of type " + storagePool.getPoolType().toString() + " with overprovisioning factor "

+ overProvFactor.toString());

s_logger.debug("Total over provisioned capacity calculated is " + overProvFactor + " * " + storagePool.getCapacityBytes());

} else {

s_logger.debug("Found storage pool " + storagePool.getName() + " of type " + storagePool.getPoolType().toString());

totalOverProvCapacity = storagePool.getCapacityBytes();

}

s_logger.debug("Total over provisioned capacity of the pool " + storagePool.getName() + " id: " + storagePool.getId() + " is " + totalOverProvCapacity);

CapacityState capacityState = CapacityState.Enabled;

if (storagePool.getScope() == ScopeType.ZONE) {

DataCenterVO dc = ApiDBUtils.findZoneById(storagePool.getDataCenterId());

AllocationState allocationState = dc.getAllocationState();

capacityState = (allocationState == AllocationState.Disabled) ? CapacityState.Disabled : CapacityState.Enabled;

} else {

if (storagePool.getClusterId() != null) {

ClusterVO cluster = ApiDBUtils.findClusterById(storagePool.getClusterId());

if (cluster != null) {

AllocationState allocationState = _configMgr.findClusterAllocationState(cluster);

capacityState = (allocationState == AllocationState.Disabled) ? CapacityState.Disabled : CapacityState.Enabled;

}

}

}

if (capacities.size() == 0) {

CapacityVO capacity =

new CapacityVO(storagePool.getId(), storagePool.getDataCenterId(), storagePool.getPodId(), storagePool.getClusterId(), allocated, totalOverProvCapacity,

capacityType);

capacity.setCapacityState(capacityState);

_capacityDao.persist(capacity);

} else {

CapacityVO capacity = capacities.get(0);

if (capacity.getTotalCapacity() != totalOverProvCapacity || allocated != 0L || capacity.getCapacityState() != capacityState) {

capacity.setTotalCapacity(totalOverProvCapacity);

capacity.setUsedCapacity(allocated);

capacity.setCapacityState(capacityState);

_capacityDao.update(capacity.getId(), capacity);

}

}

s_logger.debug("Successfully set Capacity - " + totalOverProvCapacity + " for capacity type - " + capacityType + " , DataCenterId - " +

storagePool.getDataCenterId() + ", HostOrPoolId - " + storagePool.getId() + ", PodId " + storagePool.getPodId());

}

@Override

public List<Long> getUpHostsInPool(long poolId) {

SearchCriteria<Long> sc = UpHostsInPoolSearch.create();

sc.setParameters("pool", poolId);

sc.setJoinParameters("hosts", "status", Status.Up);

sc.setJoinParameters("hosts", "resourceState", ResourceState.Enabled);

return _storagePoolHostDao.customSearch(sc, null);

}

@Override

public Pair<Long, Answer[]> sendToPool(StoragePool pool, long[] hostIdsToTryFirst, List<Long> hostIdsToAvoid, Commands cmds) throws StorageUnavailableException {

List<Long> hostIds = getUpHostsInPool(pool.getId());

Collections.shuffle(hostIds);

if (hostIdsToTryFirst != null) {

for (int i = hostIdsToTryFirst.length - 1; i >= 0; i--) {

if (hostIds.remove(hostIdsToTryFirst[i])) {

hostIds.add(0, hostIdsToTryFirst[i]);

}

}

}

if (hostIdsToAvoid != null) {

hostIds.removeAll(hostIdsToAvoid);

}

if (hostIds == null || hostIds.isEmpty()) {

throw new StorageUnavailableException("Unable to send command to the pool " + pool.getId() + " due to there is no enabled hosts up in this cluster",