// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License.  You may obtain a copy of the License at

//

//   http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied.  See the License for the

// specific language governing permissions and limitations

// under the License.

@Local(value = { StorageManager.class, StorageService.class })

    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<StoragePoolAllocator> _storagePoolAllocators;

    public List<StoragePoolAllocator> getStoragePoolAllocators() {

        return _storagePoolAllocators;

    }

    public void setStoragePoolAllocators(List<StoragePoolAllocator> _storagePoolAllocators) {

        this._storagePoolAllocators = _storagePoolAllocators;

    }

    protected List<StoragePoolDiscoverer> _discoverers;

    public List<StoragePoolDiscoverer> getDiscoverers() {

        return _discoverers;

    }

    public void setDiscoverers(List<StoragePoolDiscoverer> _discoverers) {

        this._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 _downloadUrlCleanupInterval;

    int _downloadUrlExpirationInterval;

    private int _createVolumeFromSnapshotWait;

    private int _copyvolumewait;

    int _storagePoolAcquisitionWaitSeconds = 1800; // 30 minutes

    protected int _retry = 2;

    protected int _pingInterval = 60; // seconds

    protected int _hostRetry;

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

    private long _maxVolumeSizeInGb;

    private long _serverId;

    private int _customDiskOfferingMinSize = 1;

    private int _customDiskOfferingMaxSize = 1024;

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

    private boolean _recreateSystemVmEnabled;

    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 StoragePool findStoragePool(DiskProfile dskCh, final DataCenterVO dc, HostPodVO pod, Long clusterId, Long hostId, VMInstanceVO vm,

            final Set<StoragePool> avoid) {

        Long podId = null;

        if (pod != null) {

            podId = pod.getId();

        } else if (clusterId != null) {

            ClusterVO cluster = _clusterDao.findById(clusterId);

            if (cluster != null) {

                podId = cluster.getPodId();

            }

        }

        VirtualMachineProfile<VMInstanceVO> profile = new VirtualMachineProfileImpl<VMInstanceVO>(vm);

        for (StoragePoolAllocator allocator : _storagePoolAllocators) {

            ExcludeList avoidList = new ExcludeList();

            for (StoragePool pool : avoid) {

                avoidList.addPool(pool.getId());

            }

            DataCenterDeployment plan = new DataCenterDeployment(dc.getId(), podId, clusterId, hostId, null, null);

            final List<StoragePool> poolList = allocator.allocateToPool(dskCh, profile, plan, avoidList, 1);

            if (poolList != null && !poolList.isEmpty()) {

                return (StoragePool) this.dataStoreMgr.getDataStore(poolList.get(0).getId(), DataStoreRole.Primary);

            }

        }

        return null;

    }

    @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;

                    }

                }

            }

            /*

             * Can't find the vm where host resides on(vm is destroyed? or

             * volume is detached from vm), randomly choose a host to send the

             * cmd

             */

        }

        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);

        _retry = NumbersUtil.parseInt(configs.get(Config.StartRetry.key()), 10);

        _pingInterval = NumbersUtil.parseInt(configs.get("ping.interval"), 60);

        _hostRetry = NumbersUtil.parseInt(configs.get("host.retry"), 2);

        _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.CreateVolumeFromSnapshotWait.toString());

        _createVolumeFromSnapshotWait = NumbersUtil.parseInt(value, Integer.parseInt(Config.CreateVolumeFromSnapshotWait.getDefaultValue()));

        value = _configDao.getValue(Config.CopyVolumeWait.toString());

        _copyvolumewait = NumbersUtil.parseInt(value, Integer.parseInt(Config.CopyVolumeWait.getDefaultValue()));

        value = _configDao.getValue(Config.RecreateSystemVmEnabled.key());

        _recreateSystemVmEnabled = Boolean.parseBoolean(value);

        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 workers = configs.get("expunge.workers");

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

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

        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);

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

        String maxVolumeSizeInGbString = _configDao.getValue("storage.max.volume.size");

        _maxVolumeSizeInGb = NumbersUtil.parseLong(maxVolumeSizeInGbString, 2000);

        String _customDiskOfferingMinSizeStr = _configDao.getValue(Config.CustomDiskOfferingMinSize.toString());

        _customDiskOfferingMinSize = NumbersUtil.parseInt(_customDiskOfferingMinSizeStr,

                Integer.parseInt(Config.CustomDiskOfferingMinSize.getDefaultValue()));

        String _customDiskOfferingMaxSizeStr = _configDao.getValue(Config.CustomDiskOfferingMaxSize.toString());

        _customDiskOfferingMaxSize = NumbersUtil.parseInt(_customDiskOfferingMaxSizeStr,

                Integer.parseInt(Config.CustomDiskOfferingMaxSize.getDefaultValue()));

        _serverId = _msServer.getId();

        UpHostsInPoolSearch = _storagePoolHostDao.createSearchBuilder(Long.class);

        UpHostsInPoolSearch.selectField(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());

        return true;

    }

    @Override

    public String getStoragePoolTags(long poolId) {

        return _configMgr.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 || !dc.isLocalStorageEnabled()) {

            return null;

        }

        DataStore store;

        try {

            StoragePoolVO pool = _storagePoolDao.findPoolByHostPath(host.getDataCenterId(), host.getPodId(), pInfo.getHost(), 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(), pInfo.getHost(), "", 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(), pInfo.getHost(), 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 = this.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);

            }

            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

    @SuppressWarnings("rawtypes")

    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.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 = UserContext.current().getCaller();

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

            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);

            // clean up the db

            if (store != null) {

                lifeCycle.deleteDataStore(store);

            }

            throw new CloudRuntimeException("Failed to add data store", 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.getDetails(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;

            }

            else if (capacityBytes < pool.getCapacityBytes()) {

                throw new CloudRuntimeException("The value of 'Capacity bytes' cannot be reduced in this version.");

            }

        }

        Long updatedCapacityIops = null;

        Long capacityIops = cmd.getCapacityIops();

        if (capacityIops != null) {

            if (capacityIops > pool.getCapacityIops()) {

                updatedCapacityIops = capacityIops;

            }

            else if (capacityIops < pool.getCapacityIops()) {

                throw new CloudRuntimeException("The value of 'Capacity IOPS' cannot be reduced in this version.");

            }

        }

        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 = this.volService.expungeVolumeAsync(this.volFactory.getVolume(vol.getId()));

                    try {

                        future.get();

                    } catch (InterruptedException e) {