// 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 final static Logger s_logger = Logger.getLogger(VolumeApiServiceImpl.class);

    public static final String VM_WORK_JOB_HANDLER = VolumeApiServiceImpl.class.getSimpleName();

    @Inject

    VolumeOrchestrationService _volumeMgr;

    @Inject

    EntityManager _entityMgr;

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

    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

    SnapshotService snapshotSrv;

    @Inject

    protected HypervisorCapabilitiesDao _hypervisorCapabilitiesDao;

    @Inject

    StorageManager storageMgr;

    @Inject

    protected AsyncJobManager _jobMgr;

    @Inject

    protected VmWorkJobDao _workJobDao;

    VmWorkJobHandlerProxy _jobHandlerProxy = new VmWorkJobHandlerProxy(this);

    // TODO

    static final ConfigKey<Boolean> VmJobEnabled = new ConfigKey<Boolean>("Advanced",

            Boolean.class, "vm.job.enabled", "false",

            "True to enable new VM sync model. false to use the old way", false);

    static final ConfigKey<Long> VmJobCheckInterval = new ConfigKey<Long>("Advanced",

            Long.class, "vm.job.check.interval", "3000",

            "Interval in milliseconds to check if the job is complete", false);

    private long _maxVolumeSizeInGb;

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

    protected VolumeApiServiceImpl() {

        _volStateMachine = Volume.State.getStateMachine();

    }

    /*

     * 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 = CallContext.current().getCallingAccount();

        long ownerId = cmd.getEntityOwnerId();

        Account owner = _entityMgr.findById(Account.class, 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("vhdx")) && (!url.toLowerCase().endsWith("vhdx.zip")) &&

            (!url.toLowerCase().endsWith("vhdx.gz")) && (!url.toLowerCase().endsWith("vhdx.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("vhdx") && (!url.toLowerCase().endsWith(".vhdx") && !url.toLowerCase().endsWith("vhdx.zip") && !url.toLowerCase().endsWith("vhdx.bz2") &&

                !url.toLowerCase().endsWith("vhdx.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;

    }

    public String getRandomVolumeName() {

        return UUID.randomUUID().toString();

    }

    @DB

    protected VolumeVO persistVolume(final Account owner, final Long zoneId, final String volumeName, final String url, final String format) {

        return Transaction.execute(new TransactionCallback<VolumeVO>() {

            @Override

            public VolumeVO doInTransaction(TransactionStatus status) {

                VolumeVO volume = new VolumeVO(volumeName, zoneId, -1, -1, -1, new Long(-1), null, null, 0, Volume.Type.DATADISK);

                volume.setPoolId(null);

                volume.setDataCenterId(zoneId);

                volume.setPodId(null);

                volume.setAccountId((owner == null) ? null : owner.getAccountId());

                volume.setDomainId((owner == null) ? Domain.ROOT_DOMAIN : owner.getDomainId());

                long diskOfferingId = _diskOfferingDao.findByUniqueName("Cloud.com-Custom").getId();

                volume.setDiskOfferingId(diskOfferingId);

                // volume.setSize(size);

                volume.setInstanceId(null);

                volume.setUpdated(new Date());

                volume.setDomainId((owner == null) ? Domain.ROOT_DOMAIN : owner.getDomainId());

                volume.setFormat(ImageFormat.valueOf(format));

                volume = _volsDao.persist(volume);

                CallContext.current().setEventDetails("Volume Id: " + volume.getId());

                // Increment resource count during allocation; if actual creation fails,

                // decrement it

                _resourceLimitMgr.incrementResourceCount(volume.getAccountId(), ResourceType.volume);

                _resourceLimitMgr.incrementResourceCount(volume.getAccountId(), ResourceType.secondary_storage, UriUtils.getRemoteSize(url));

                return volume;

            }

        });

    }

    /*

     * Just allocate a volume in the database, don't send the createvolume cmd

     * to hypervisor. The volume will be finally created only when it's attached

     * to a VM.

     */

    @Override

    @DB

    @ActionEvent(eventType = EventTypes.EVENT_VOLUME_CREATE, eventDescription = "creating volume", create = true)

    public VolumeVO allocVolume(CreateVolumeCmd cmd) throws ResourceAllocationException {

        // FIXME: some of the scheduled event stuff might be missing here...

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

        long ownerId = cmd.getEntityOwnerId();

        Boolean displayVolumeEnabled = cmd.getDisplayVolume();

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

        Long zoneId = cmd.getZoneId();

        Long diskOfferingId = null;

        DiskOfferingVO diskOffering = null;

        Long size = null;

        Long minIops = null;

        Long maxIops = null;

        // Volume VO used for extracting the source template id

        VolumeVO parentVolume = null;

        // validate input parameters before creating the volume

        if ((cmd.getSnapshotId() == null && cmd.getDiskOfferingId() == null) || (cmd.getSnapshotId() != null && cmd.getDiskOfferingId() != null)) {

            throw new InvalidParameterValueException("Either disk Offering Id or snapshot Id must be passed whilst creating volume");

        }

        if (cmd.getSnapshotId() == null) {// create a new volume

            diskOfferingId = cmd.getDiskOfferingId();

            size = cmd.getSize();

            Long sizeInGB = size;

            if (size != null) {

                if (size > 0) {

                    size = size * 1024 * 1024 * 1024; // user specify size in GB

                } else {

                    throw new InvalidParameterValueException("Disk size must be larger than 0");

                }

            }

            // Check that the the disk offering is specified

            diskOffering = _diskOfferingDao.findById(diskOfferingId);

            if ((diskOffering == null) || diskOffering.getRemoved() != null || !DiskOfferingVO.Type.Disk.equals(diskOffering.getType())) {

                throw new InvalidParameterValueException("Please specify a valid disk offering.");

            }

            if (diskOffering.isCustomized()) {

                if (size == null) {

                    throw new InvalidParameterValueException("This disk offering requires a custom size specified");

                }

                Long customDiskOfferingMaxSize = _volumeMgr.CustomDiskOfferingMaxSize.value();

                Long customDiskOfferingMinSize = _volumeMgr.CustomDiskOfferingMinSize.value();

                if ((sizeInGB < customDiskOfferingMinSize) || (sizeInGB > customDiskOfferingMaxSize)) {

                    throw new InvalidParameterValueException("Volume size: " + sizeInGB + "GB is out of allowed range. Max: " + customDiskOfferingMaxSize + " Min:" +

                            customDiskOfferingMinSize);

                }

            }

            if (!diskOffering.isCustomized() && size != null) {

                throw new InvalidParameterValueException("This disk offering does not allow custom size");

            }

            if (diskOffering.getDomainId() == null) {

                // do nothing as offering is public

            } else {

                _configMgr.checkDiskOfferingAccess(caller, diskOffering);

            }

            if (diskOffering.getDiskSize() > 0) {

                size = diskOffering.getDiskSize();

            }

            Boolean isCustomizedIops = diskOffering.isCustomizedIops();

            if (isCustomizedIops != null) {

                if (isCustomizedIops) {

                    minIops = cmd.getMinIops();

                    maxIops = cmd.getMaxIops();

                    if (minIops == null && maxIops == null) {

                        minIops = 0L;

                        maxIops = 0L;

                    } else {

                        if (minIops == null || minIops <= 0) {

                            throw new InvalidParameterValueException("The min IOPS must be greater than 0.");

                        }

                        if (maxIops == null) {

                            maxIops = 0L;

                        }

                        if (minIops > maxIops) {

                            throw new InvalidParameterValueException("The min IOPS must be less than or equal to the max IOPS.");

                        }

                    }

                } else {

                    minIops = diskOffering.getMinIops();

                    maxIops = diskOffering.getMaxIops();

                }

            }

            if (!validateVolumeSizeRange(size)) {// convert size from mb to gb

                // for validation

                throw new InvalidParameterValueException("Invalid size for custom volume creation: " + size + " ,max volume size is:" + _maxVolumeSizeInGb);

            }

        } else { // create volume from snapshot

            Long snapshotId = cmd.getSnapshotId();

            SnapshotVO snapshotCheck = _snapshotDao.findById(snapshotId);

            if (snapshotCheck == null) {

                throw new InvalidParameterValueException("unable to find a snapshot with id " + snapshotId);

            }

            if (snapshotCheck.getState() != Snapshot.State.BackedUp) {

                throw new InvalidParameterValueException("Snapshot id=" + snapshotId + " is not in " + Snapshot.State.BackedUp + " state yet and can't be used for volume creation");

            }

            parentVolume = _volsDao.findByIdIncludingRemoved(snapshotCheck.getVolumeId());

            diskOfferingId = snapshotCheck.getDiskOfferingId();

            diskOffering = _diskOfferingDao.findById(diskOfferingId);

            if (zoneId == null) {

                // if zoneId is not provided, we default to create volume in the same zone as the snapshot zone.

                zoneId = snapshotCheck.getDataCenterId();

            }

            size = snapshotCheck.getSize(); // ; disk offering is used for tags

            // purposes

            // check snapshot permissions

            _accountMgr.checkAccess(caller, null, true, snapshotCheck);

            // one step operation - create volume in VM's cluster and attach it

            // to the VM

            Long vmId = cmd.getVirtualMachineId();

            if (vmId != null) {

                // Check that the virtual machine ID is valid and it's a user vm

                UserVmVO vm = _userVmDao.findById(vmId);

                if (vm == null || vm.getType() != VirtualMachine.Type.User) {

                    throw new InvalidParameterValueException("Please specify a valid User VM.");

                }

                // Check that the VM is in the correct state

                if (vm.getState() != State.Running && vm.getState() != State.Stopped) {

                    throw new InvalidParameterValueException("Please specify a VM that is either running or stopped.");

                }

                // permission check

                _accountMgr.checkAccess(caller, null, false, vm);

            }

        }

        if (displayVolumeEnabled == null) {

            displayVolumeEnabled = true;

        } else {

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

                throw new PermissionDeniedException("Cannot update parameter displayvolume, only admin permitted ");

            }

        }

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

        _resourceLimitMgr.checkResourceLimit(_accountMgr.getAccount(ownerId), ResourceType.primary_storage, new Long(size));

        // 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 local storage is disabled then creation of volume with local disk

        // offering not allowed

        if (!zone.isLocalStorageEnabled() && diskOffering.getUseLocalStorage()) {

            throw new InvalidParameterValueException("Zone is not configured to use local storage but volume's disk offering " + diskOffering.getName() + " uses it");

        }

        String userSpecifiedName = cmd.getVolumeName();

        if (userSpecifiedName == null) {

            userSpecifiedName = getRandomVolumeName();

        }

        VolumeVO volume = commitVolume(cmd, caller, ownerId, displayVolumeEnabled, zoneId, diskOfferingId, size,

                minIops, maxIops, parentVolume, userSpecifiedName);

        return volume;

    }

    private VolumeVO commitVolume(final CreateVolumeCmd cmd, final Account caller, final long ownerId, final Boolean displayVolumeEnabled,

            final Long zoneId, final Long diskOfferingId, final Long size, final Long minIops, final Long maxIops, final VolumeVO parentVolume,

            final String userSpecifiedName) {

        return Transaction.execute(new TransactionCallback<VolumeVO>() {

            @Override

            public VolumeVO doInTransaction(TransactionStatus status) {

        VolumeVO volume = new VolumeVO(userSpecifiedName, -1, -1, -1, -1, new Long(-1), null, null, 0, Volume.Type.DATADISK);

        volume.setPoolId(null);

        volume.setDataCenterId(zoneId);

        volume.setPodId(null);

        volume.setAccountId(ownerId);

        volume.setDomainId(((caller == null) ? Domain.ROOT_DOMAIN : caller.getDomainId()));

        volume.setDiskOfferingId(diskOfferingId);

        volume.setSize(size);

        volume.setMinIops(minIops);

        volume.setMaxIops(maxIops);

        volume.setInstanceId(null);

        volume.setUpdated(new Date());

        volume.setDomainId((caller == null) ? Domain.ROOT_DOMAIN : caller.getDomainId());

        volume.setDisplayVolume(displayVolumeEnabled);

        if (parentVolume != null) {

            volume.setTemplateId(parentVolume.getTemplateId());

            volume.setFormat(parentVolume.getFormat());

        } else {

            volume.setTemplateId(null);

        }

        volume = _volsDao.persist(volume);

        if (cmd.getSnapshotId() == null) {

            // for volume created from snapshot, create usage event after volume creation

            UsageEventUtils.publishUsageEvent(EventTypes.EVENT_VOLUME_CREATE, volume.getAccountId(), volume.getDataCenterId(), volume.getId(), volume.getName(), diskOfferingId,

                    null, size, Volume.class.getName(), volume.getUuid());

        }

        CallContext.current().setEventDetails("Volume Id: " + volume.getId());

        // Increment resource count during allocation; if actual creation fails,

        // decrement it

        _resourceLimitMgr.incrementResourceCount(volume.getAccountId(), ResourceType.volume);

        _resourceLimitMgr.incrementResourceCount(volume.getAccountId(), ResourceType.primary_storage, new Long(volume.getSize()));

        return volume;

    }

        });

    }

    public boolean validateVolumeSizeRange(long size) {

        if (size < 0 || (size > 0 && size < (1024 * 1024 * 1024))) {

            throw new InvalidParameterValueException("Please specify a size of at least 1 Gb.");

        } else if (size > (_maxVolumeSizeInGb * 1024 * 1024 * 1024)) {

            throw new InvalidParameterValueException("volume size " + size + ", but the maximum size allowed is " + _maxVolumeSizeInGb + " Gb.");

        }

        return true;

    }

    @Override

    @DB

    @ActionEvent(eventType = EventTypes.EVENT_VOLUME_CREATE, eventDescription = "creating volume", async = true)

    public VolumeVO createVolume(CreateVolumeCmd cmd) {

        VolumeVO volume = _volsDao.findById(cmd.getEntityId());

        boolean created = true;

        try {

            if (cmd.getSnapshotId() != null) {