* Licensed to the Apache Software Foundation (ASF) under one

* 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.

*/

    private static final Logger s_logger = Logger

            .getLogger(VolumeManagerImpl.class);

    @Inject

    protected UserVmManager _userVmMgr;

    @Inject

    protected AgentManager _agentMgr;

    @Inject

    protected TemplateManager _tmpltMgr;

    @Inject

    protected AsyncJobManager _asyncMgr;

    @Inject

    protected SnapshotManager _snapshotMgr;

    @Inject

    protected SnapshotScheduler _snapshotScheduler;

    @Inject

    protected AccountManager _accountMgr;

    @Inject

    protected ConfigurationManager _configMgr;

    @Inject

    protected ConsoleProxyManager _consoleProxyMgr;

    @Inject

    protected SecondaryStorageVmManager _secStorageMgr;

    @Inject

    protected NetworkModel _networkMgr;

    @Inject

    protected ServiceOfferingDao _serviceOfferingDao;

    @Inject

    protected VolumeDao _volsDao;

    @Inject

    protected HostDao _hostDao;

    @Inject

    protected ConsoleProxyDao _consoleProxyDao;

    @Inject

    protected SnapshotDao _snapshotDao;

    @Inject

    protected SnapshotManager _snapMgr;

    @Inject

    protected SnapshotPolicyDao _snapshotPolicyDao;

    @Inject

    protected StoragePoolHostDao _storagePoolHostDao;

    @Inject

    StoragePoolDetailsDao storagePoolDetailsDao;

    @Inject

    protected AlertManager _alertMgr;

    @Inject

    protected TemplateDataStoreDao _vmTemplateStoreDao = null;

    @Inject

    protected VMTemplatePoolDao _vmTemplatePoolDao = null;

    @Inject

    protected VMTemplateDao _vmTemplateDao = null;

    @Inject

    protected StoragePoolHostDao _poolHostDao = null;

    @Inject

    protected UserVmDao _userVmDao;

    @Inject

    VolumeDataStoreDao _volumeStoreDao;

    @Inject

    protected VMInstanceDao _vmInstanceDao;

    @Inject

    protected PrimaryDataStoreDao _storagePoolDao = null;

    @Inject

    protected CapacityDao _capacityDao;

    @Inject

    protected CapacityManager _capacityMgr;

    @Inject

    protected DiskOfferingDao _diskOfferingDao;

    @Inject

    protected AccountDao _accountDao;

    @Inject

    protected EventDao _eventDao = null;

    @Inject

    protected DataCenterDao _dcDao = null;

    @Inject

    protected HostPodDao _podDao = null;

    @Inject

    protected VMTemplateDao _templateDao;

    @Inject

    protected ServiceOfferingDao _offeringDao;

    @Inject

    protected DomainDao _domainDao;

    @Inject

    protected UserDao _userDao;

    @Inject

    protected ClusterDao _clusterDao;

    @Inject

    protected VirtualMachineManager _vmMgr;

    @Inject

    protected DomainRouterDao _domrDao;

    @Inject

    protected SecondaryStorageVmDao _secStrgDao;

    @Inject

    protected StoragePoolWorkDao _storagePoolWorkDao;

    @Inject

    protected HypervisorGuruManager _hvGuruMgr;

    @Inject

    protected VolumeDao _volumeDao;

    @Inject

    protected OCFS2Manager _ocfs2Mgr;

    @Inject

    protected ResourceLimitService _resourceLimitMgr;

    @Inject

    protected SecondaryStorageVmManager _ssvmMgr;

    @Inject

    protected ResourceManager _resourceMgr;

    @Inject

    protected DownloadMonitor _downloadMonitor;

    @Inject

    protected ResourceTagDao _resourceTagDao;

    @Inject

    protected VmDiskStatisticsDao _vmDiskStatsDao;

    @Inject

    protected VMSnapshotDao _vmSnapshotDao;

    @Inject

    protected List<StoragePoolAllocator> _storagePoolAllocators;

    @Inject

    ConfigurationDao _configDao;

    @Inject

    VolumeDetailsDao _volDetailDao;

    @Inject

    ManagementServer _msServer;

    @Inject

    DataStoreManager dataStoreMgr;

    @Inject

    DataStoreProviderManager dataStoreProviderMgr;

    @Inject

    VolumeService volService;

    @Inject

    VolumeDataFactory volFactory;

    @Inject

    TemplateDataFactory tmplFactory;

    @Inject

    SnapshotDataFactory snapshotFactory;

    @Inject

    SnapshotApiService snapshotMgr;

    @Inject

    UploadMonitor _uploadMonitor;

    @Inject

    UploadDao _uploadDao;

    private int _copyvolumewait;

    @Inject

    protected HypervisorCapabilitiesDao _hypervisorCapabilitiesDao;

    private final StateMachine2<Volume.State, Volume.Event, Volume> _volStateMachine;

    @Inject

    StorageManager storageMgr;

    private int _customDiskOfferingMinSize = 1;

    private final int _customDiskOfferingMaxSize = 1024;

    private long _maxVolumeSizeInGb;

    private boolean _recreateSystemVmEnabled;

    private boolean _storageHAMigrationEnabled;   

    public VolumeManagerImpl() {

        _volStateMachine = Volume.State.getStateMachine();

    }

    @Override

    public VolumeInfo moveVolume(VolumeInfo volume, long destPoolDcId,

            Long destPoolPodId, Long destPoolClusterId,

            HypervisorType dataDiskHyperType)

                    throws ConcurrentOperationException, StorageUnavailableException {

        // Find a destination storage pool with the specified criteria

        DiskOfferingVO diskOffering = _diskOfferingDao.findById(volume

                .getDiskOfferingId());

        DiskProfile dskCh = new DiskProfile(volume.getId(),

                volume.getVolumeType(), volume.getName(), diskOffering.getId(),

                diskOffering.getDiskSize(), diskOffering.getTagsArray(),

                diskOffering.getUseLocalStorage(),

                diskOffering.isRecreatable(), null);

        dskCh.setHyperType(dataDiskHyperType);

        DataCenterVO destPoolDataCenter = _dcDao.findById(destPoolDcId);

        HostPodVO destPoolPod = _podDao.findById(destPoolPodId);

        StoragePool destPool = storageMgr.findStoragePool(dskCh,

                destPoolDataCenter, destPoolPod, destPoolClusterId, null, null,

                new HashSet<StoragePool>());

        if (destPool == null) {

            throw new CloudRuntimeException(

                    "Failed to find a storage pool with enough capacity to move the volume to.");

        }

        Volume newVol = migrateVolume(volume, destPool);

        return volFactory.getVolume(newVol.getId());

    }

    /*

     * Upload the volume to secondary storage.

     */

    @Override

    @DB

    @ActionEvent(eventType = EventTypes.EVENT_VOLUME_UPLOAD, eventDescription = "uploading volume", async = true)

    public VolumeVO uploadVolume(UploadVolumeCmd cmd)

            throws ResourceAllocationException {

        Account caller = UserContext.current().getCaller();

        long ownerId = cmd.getEntityOwnerId();

        Account owner = _accountDao.findById(ownerId);

        Long zoneId = cmd.getZoneId();

        String volumeName = cmd.getVolumeName();

        String url = cmd.getUrl();

        String format = cmd.getFormat();

        String imageStoreUuid = cmd.getImageStoreUuid();

        DataStore store = _tmpltMgr.getImageStore(imageStoreUuid, zoneId);

        validateVolume(caller, ownerId, zoneId, volumeName, url, format);

        VolumeVO volume = persistVolume(owner, zoneId, volumeName,

                url, cmd.getFormat());

        VolumeInfo vol = volFactory.getVolume(volume.getId());

        RegisterVolumePayload payload = new RegisterVolumePayload(cmd.getUrl(), cmd.getChecksum(),

                cmd.getFormat());

        vol.addPayload(payload);

        volService.registerVolume(vol, store);

        return volume;

    }

    private boolean validateVolume(Account caller, long ownerId, Long zoneId,

            String volumeName, String url, String format)

                    throws ResourceAllocationException {

        // permission check

        _accountMgr.checkAccess(caller, null, true,

                _accountMgr.getActiveAccountById(ownerId));

        // Check that the resource limit for volumes won't be exceeded

        _resourceLimitMgr.checkResourceLimit(_accountMgr.getAccount(ownerId),

                ResourceType.volume);

        // Verify that zone exists

        DataCenterVO zone = _dcDao.findById(zoneId);

        if (zone == null) {

            throw new InvalidParameterValueException(

                    "Unable to find zone by id " + zoneId);

        }

        // Check if zone is disabled

        if (Grouping.AllocationState.Disabled == zone.getAllocationState()

                && !_accountMgr.isRootAdmin(caller.getType())) {

            throw new PermissionDeniedException(

                    "Cannot perform this operation, Zone is currently disabled: "

                            + zoneId);

        }

        if (url.toLowerCase().contains("file://")) {

            throw new InvalidParameterValueException(

                    "File:// type urls are currently unsupported");

        }

        ImageFormat imgfmt = ImageFormat.valueOf(format.toUpperCase());

        if (imgfmt == null) {

            throw new IllegalArgumentException("Image format is incorrect "

                    + format + ". Supported formats are "

                    + EnumUtils.listValues(ImageFormat.values()));

        }

        String userSpecifiedName = volumeName;

        if (userSpecifiedName == null) {

            userSpecifiedName = getRandomVolumeName();

        }

        if ((!url.toLowerCase().endsWith("vhd"))

                && (!url.toLowerCase().endsWith("vhd.zip"))

                && (!url.toLowerCase().endsWith("vhd.bz2"))

                && (!url.toLowerCase().endsWith("vhd.gz"))

                && (!url.toLowerCase().endsWith("qcow2"))

                && (!url.toLowerCase().endsWith("qcow2.zip"))

                && (!url.toLowerCase().endsWith("qcow2.bz2"))

                && (!url.toLowerCase().endsWith("qcow2.gz"))

                && (!url.toLowerCase().endsWith("ova"))

                && (!url.toLowerCase().endsWith("ova.zip"))

                && (!url.toLowerCase().endsWith("ova.bz2"))

                && (!url.toLowerCase().endsWith("ova.gz"))

                && (!url.toLowerCase().endsWith("img"))

                && (!url.toLowerCase().endsWith("raw"))) {

            throw new InvalidParameterValueException("Please specify a valid "

                    + format.toLowerCase());

        }

        if ((format.equalsIgnoreCase("vhd") && (!url.toLowerCase().endsWith(

                ".vhd")

                && !url.toLowerCase().endsWith("vhd.zip")

                && !url.toLowerCase().endsWith("vhd.bz2") && !url.toLowerCase()

                .endsWith("vhd.gz")))

                || (format.equalsIgnoreCase("qcow2") && (!url.toLowerCase()

                        .endsWith(".qcow2")

                        && !url.toLowerCase().endsWith("qcow2.zip")

                        && !url.toLowerCase().endsWith("qcow2.bz2") && !url

                        .toLowerCase().endsWith("qcow2.gz")))

                        || (format.equalsIgnoreCase("ova") && (!url.toLowerCase()

                                .endsWith(".ova")

                                && !url.toLowerCase().endsWith("ova.zip")

                                && !url.toLowerCase().endsWith("ova.bz2") && !url

                                .toLowerCase().endsWith("ova.gz")))

                                || (format.equalsIgnoreCase("raw") && (!url.toLowerCase()

                                        .endsWith(".img") && !url.toLowerCase().endsWith("raw")))) {

            throw new InvalidParameterValueException(

                    "Please specify a valid URL. URL:" + url

                    + " is an invalid for the format "

                    + format.toLowerCase());

        }

        UriUtils.validateUrl(url);

        // Check that the resource limit for secondary storage won't be exceeded

        _resourceLimitMgr.checkResourceLimit(_accountMgr.getAccount(ownerId), ResourceType.secondary_storage,

                UriUtils.getRemoteSize(url));

        return false;

    }

    @Override

    public VolumeVO allocateDuplicateVolume(VolumeVO oldVol, Long templateId) {

        VolumeVO newVol = new VolumeVO(oldVol.getVolumeType(),

                oldVol.getName(), oldVol.getDataCenterId(),

                oldVol.getDomainId(), oldVol.getAccountId(),

                oldVol.getDiskOfferingId(), oldVol.getSize(),

                oldVol.getMinIops(), oldVol.getMaxIops(), oldVol.get_iScsiName());

        if (templateId != null) {

            newVol.setTemplateId(templateId);

        } else {

            newVol.setTemplateId(oldVol.getTemplateId());

        }

        newVol.setDeviceId(oldVol.getDeviceId());

        newVol.setInstanceId(oldVol.getInstanceId());

        newVol.setRecreatable(oldVol.isRecreatable());

        newVol.setFormat(oldVol.getFormat());

        return _volsDao.persist(newVol);

    }

    @DB

    protected VolumeInfo createVolumeFromSnapshot(VolumeVO volume,

            SnapshotVO snapshot) throws StorageUnavailableException {

        Account account = _accountDao.findById(volume.getAccountId());

        final HashSet<StoragePool> poolsToAvoid = new HashSet<StoragePool>();

        StoragePool pool = null;

        Set<Long> podsToAvoid = new HashSet<Long>();

        Pair<HostPodVO, Long> pod = null;

        DiskOfferingVO diskOffering = _diskOfferingDao

                .findByIdIncludingRemoved(volume.getDiskOfferingId());

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

        DiskProfile dskCh = new DiskProfile(volume, diskOffering,

                snapshot.getHypervisorType());

        // Determine what pod to store the volume in

        while ((pod = _resourceMgr.findPod(null, null, dc, account.getId(),

                podsToAvoid)) != null) {

            podsToAvoid.add(pod.first().getId());

            // Determine what storage pool to store the volume in

            while ((pool = storageMgr.findStoragePool(dskCh, dc, pod.first(), null, null,

                    null, poolsToAvoid)) != null) {

                break;

            }

        }

        if (pool == null) {

            String msg = "There are no available storage pools to store the volume in";

            s_logger.info(msg);

            throw new StorageUnavailableException(msg, -1);

        }

        VolumeInfo vol = volFactory.getVolume(volume.getId());

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

        SnapshotInfo snapInfo = snapshotFactory.getSnapshot(snapshot.getId(), DataStoreRole.Image);

        AsyncCallFuture<VolumeApiResult> future = volService.createVolumeFromSnapshot(vol, store, snapInfo);

        try {

            VolumeApiResult result = future.get();

            if (result.isFailed()) {

                s_logger.debug("Failed to create volume from snapshot:" + result.getResult());

                throw new CloudRuntimeException("Failed to create volume from snapshot:" + result.getResult());

            }

            return result.getVolume();

        } catch (InterruptedException e) {

            s_logger.debug("Failed to create volume from snapshot", e);

            throw new CloudRuntimeException("Failed to create volume from snapshot", e);

        } catch (ExecutionException e) {

            s_logger.debug("Failed to create volume from snapshot", e);

            throw new CloudRuntimeException("Failed to create volume from snapshot", e);

        }

    }

    protected DiskProfile createDiskCharacteristics(VolumeInfo volume,

            VMTemplateVO template, DataCenterVO dc, DiskOfferingVO diskOffering) {

        if (volume.getVolumeType() == Type.ROOT

                && Storage.ImageFormat.ISO != template.getFormat()) {

            TemplateDataStoreVO ss = _vmTemplateStoreDao.findByTemplateZoneDownloadStatus(template.getId(), dc.getId(),

                    VMTemplateStorageResourceAssoc.Status.DOWNLOADED);

            if (ss == null) {

                throw new CloudRuntimeException("Template "

                        + template.getName()

                        + " has not been completely downloaded to zone "

                        + dc.getId());

            }

            return new DiskProfile(volume.getId(), volume.getVolumeType(),

                    volume.getName(), diskOffering.getId(), ss.getSize(),

                    diskOffering.getTagsArray(),