Java ImageFormat.ISO属性代码示例

@Override
@DB
public boolean remove(final Long id) {
    final TransactionLegacy txn = TransactionLegacy.currentTxn();
    txn.start();
    final VMTemplateVO template = createForUpdate();
    template.setRemoved(new Date());

    final VMTemplateVO vo = findById(id);
    if (vo != null) {
        if (vo.getFormat() == ImageFormat.ISO) {
            _tagsDao.removeByIdAndType(id, ResourceObjectType.ISO);
        } else {
            _tagsDao.removeByIdAndType(id, ResourceObjectType.Template);
        }
    }

    final boolean result = update(id, template);
    txn.commit();
    return result;
}
 

@Override
public FormatInfo process(final String templatePath, final ImageFormat format, final String templateName) {
    if (format != null) {
        s_logger.debug("We don't handle conversion from " + format + " to ISO.");
        return null;
    }

    final String isoPath = templatePath + File.separator + templateName + "." + ImageFormat.ISO.getFileExtension();

    if (!_storage.exists(isoPath)) {
        s_logger.debug("Unable to find the iso file: " + isoPath);
        return null;
    }

    final FormatInfo info = new FormatInfo();
    info.format = ImageFormat.ISO;
    info.filename = templateName + "." + ImageFormat.ISO.getFileExtension();
    info.size = _storage.getSize(isoPath);
    info.virtualSize = info.size;

    return info;
}
 

@Override
public TemplateProfile prepareDelete(final DeleteTemplateCmd cmd) {
    final Long templateId = cmd.getId();
    Long userId = CallContext.current().getCallingUserId();
    final Account account = CallContext.current().getCallingAccount();
    final Long zoneId = cmd.getZoneId();

    final VMTemplateVO template = _tmpltDao.findById(templateId);
    if (template == null) {
        throw new InvalidParameterValueException("unable to find template with id " + templateId);
    }

    userId = accountAndUserValidation(account, userId, null, template, "Unable to delete template ");

    final UserVO user = _userDao.findById(userId);
    if (user == null) {
        throw new InvalidParameterValueException("Please specify a valid user.");
    }

    if (template.getFormat() == ImageFormat.ISO) {
        throw new InvalidParameterValueException("Please specify a valid template.");
    }

    return new TemplateProfile(userId, template, zoneId);
}
 

@Override
public List<VMTemplateStoragePoolVO> getUnusedTemplatesInPool(final StoragePoolVO pool) {
    final List<VMTemplateStoragePoolVO> unusedTemplatesInPool = new ArrayList<>();
    final List<VMTemplateStoragePoolVO> allTemplatesInPool = _tmpltPoolDao.listByPoolId(pool.getId());

    for (final VMTemplateStoragePoolVO templatePoolVO : allTemplatesInPool) {
        final VMTemplateVO template = _tmpltDao.findByIdIncludingRemoved(templatePoolVO.getTemplateId());

        // If this is a routing template, consider it in use
        if (template.getTemplateType() == TemplateType.SYSTEM) {
            continue;
        }

        // If the template is not yet downloaded to the pool, consider it in
        // use
        if (templatePoolVO.getDownloadState() != Status.DOWNLOADED) {
            continue;
        }

        if (template.getFormat() != ImageFormat.ISO && !_volumeDao.isAnyVolumeActivelyUsingTemplateOnPool(template.getId(), pool.getId())) {
            unusedTemplatesInPool.add(templatePoolVO);
        }
    }

    return unusedTemplatesInPool;
}
 

@Override
public TemplateInfo prepareIso(final long isoId, final long dcId) {
    final TemplateInfo tmplt = _tmplFactory.getTemplate(isoId, DataStoreRole.Image, dcId);
    if (tmplt == null || tmplt.getFormat() != ImageFormat.ISO) {
        s_logger.warn("ISO: " + isoId + " does not exist in vm_template table");
        return null;
    }

    if (tmplt.getDataStore() != null && !(tmplt.getDataStore().getTO() instanceof NfsTO)) {
        // if it is s3, need to download into cache storage first
        final Scope destScope = new ZoneScope(dcId);
        final TemplateInfo cacheData = (TemplateInfo) cacheMgr.createCacheObject(tmplt, destScope);
        if (cacheData == null) {
            s_logger.error("Failed in copy iso from S3 to cache storage");
            return null;
        }
        return cacheData;
    } else {
        return tmplt;
    }
}
 

@Override
@ActionEvent(eventType = EventTypes.EVENT_TEMPLATE_DELETE, eventDescription = "deleting template", async = true)
public boolean deleteTemplate(final DeleteTemplateCmd cmd) {
    final Long templateId = cmd.getId();
    final Account caller = CallContext.current().getCallingAccount();

    final VMTemplateVO template = _tmpltDao.findById(templateId);
    if (template == null) {
        throw new InvalidParameterValueException("unable to find template with id " + templateId);
    }

    _accountMgr.checkAccess(caller, AccessType.OperateEntry, true, template);

    if (template.getFormat() == ImageFormat.ISO) {
        throw new InvalidParameterValueException("Please specify a valid template.");
    }

    final TemplateAdapter adapter = getAdapter(template.getHypervisorType());
    final TemplateProfile profile = adapter.prepareDelete(cmd);
    return adapter.delete(profile);
}
 

@Override
@ActionEvent(eventType = EventTypes.EVENT_ISO_DELETE, eventDescription = "deleting iso", async = true)
public boolean deleteIso(final DeleteIsoCmd cmd) {
    final Long templateId = cmd.getId();
    final Account caller = CallContext.current().getCallingAccount();
    final Long zoneId = cmd.getZoneId();

    final VMTemplateVO template = _tmpltDao.findById(templateId);
    if (template == null) {
        throw new InvalidParameterValueException("unable to find iso with id " + templateId);
    }

    _accountMgr.checkAccess(caller, AccessType.OperateEntry, true, template);

    if (template.getFormat() != ImageFormat.ISO) {
        throw new InvalidParameterValueException("Please specify a valid iso.");
    }

    // check if there is any VM using this ISO.
    if (!templateIsDeleteable(templateId)) {
        throw new InvalidParameterValueException("Unable to delete iso, as it's used by other vms");
    }

    if (zoneId != null && _dataStoreMgr.getImageStore(zoneId) == null) {
        throw new InvalidParameterValueException("Failed to find a secondary storage store in the specified zone.");
    }

    final TemplateAdapter adapter = getAdapter(template.getHypervisorType());
    final TemplateProfile profile = adapter.prepareDelete(cmd);
    final boolean result = adapter.delete(profile);
    if (result) {
        return true;
    } else {
        throw new CloudRuntimeException("Failed to delete ISO");
    }
}
 

@Override
public Long extractTemplate(final VMTemplateVO template, final String url, final TemplateDataStoreVO vmTemplateHost, final Long dataCenterId, final long eventId, final long
        asyncJobId,
                            final AsyncJobManager asyncMgr) {

    final Type type = (template.getFormat() == ImageFormat.ISO) ? Type.ISO : Type.TEMPLATE;

    final DataStore secStore = storeMgr.getImageStore(dataCenterId);

    final UploadVO uploadTemplateObj = new UploadVO(secStore.getId(), template.getId(), new Date(), Upload.Status.NOT_UPLOADED, type, url, Mode.FTP_UPLOAD);
    _uploadDao.persist(uploadTemplateObj);

    if (vmTemplateHost != null) {
        start();
        final UploadCommand ucmd = new UploadCommand(template, url, vmTemplateHost.getInstallPath(), vmTemplateHost.getSize());
        final UploadListener ul =
                new UploadListener(secStore, _timer, _uploadDao, uploadTemplateObj, this, ucmd, template.getAccountId(), template.getName(), type, eventId, asyncJobId,
                        asyncMgr);
        _listenerMap.put(uploadTemplateObj, ul);
        try {
            final EndPoint ep = _epSelector.select(secStore);
            if (ep == null) {
                final String errMsg = "No remote endpoint to send command, check if host or ssvm is down?";
                s_logger.error(errMsg);
                return null;
            }
            ep.sendMessageAsync(ucmd, new UploadListener.Callback(ep.getId(), ul));
        } catch (final Exception e) {
            s_logger.warn("Unable to start upload of " + template.getUniqueName() + " from " + secStore.getName() + " to " + url, e);
            ul.setDisconnected();
            ul.scheduleStatusCheck(RequestType.GET_OR_RESTART);
        }
        return uploadTemplateObj.getId();
    }
    return null;
}
 

@Override
public DiskProfile allocateRawVolume(final Type type, final String name, final DiskOffering offering, Long size, Long minIops, Long maxIops, final VirtualMachine vm, final
VirtualMachineTemplate template, final Account owner) {
    if (size == null) {
        size = offering.getDiskSize();
    } else {
        size = (size * 1024 * 1024 * 1024);
    }

    minIops = minIops != null ? minIops : offering.getMinIops();
    maxIops = maxIops != null ? maxIops : offering.getMaxIops();

    VolumeVO vol = new VolumeVO(type,
            name,
            vm.getDataCenterId(),
            owner.getDomainId(),
            owner.getId(),
            offering.getId(),
            offering.getProvisioningType(),
            size,
            minIops,
            maxIops,
            null);
    if (vm != null) {
        vol.setInstanceId(vm.getId());
    }

    if (type.equals(Type.ROOT)) {
        vol.setDeviceId(0l);
    } else {
        vol.setDeviceId(1l);
    }
    if (template.getFormat() == ImageFormat.ISO) {
        vol.setIsoId(template.getId());
    }
    // display flag matters only for the User vms
    if (vm.getType() == VirtualMachine.Type.User) {
        final UserVmVO userVm = _userVmDao.findById(vm.getId());
        vol.setDisplayVolume(userVm.isDisplayVm());
    }

    vol.setFormat(getSupportedImageFormatForCluster(vm.getHypervisorType()));
    vol = _volsDao.persist(vol);

    // Save usage event and update resource count for user vm volumes
    if (vm.getType() == VirtualMachine.Type.User) {
        _resourceLimitMgr.incrementResourceCount(vm.getAccountId(), ResourceType.volume, vol.isDisplayVolume());
        _resourceLimitMgr.incrementResourceCount(vm.getAccountId(), ResourceType.primary_storage, vol.isDisplayVolume(), new Long(vol.getSize()));
    }
    return toDiskProfile(vol, offering);
}
 

@Override
@ActionEvent(eventType = EventTypes.EVENT_VM_CREATE, eventDescription = "deploying Vm", create = true)
public UserVm createAdvancedVirtualMachine(final Zone zone, final ServiceOffering serviceOffering, final VirtualMachineTemplate template, final List<Long>
        networkIdList, final Account owner,
                                           final String hostName, final String displayName, final Long diskOfferingId, final Long diskSize, final String group, final
                                           HypervisorType hypervisor, final HTTPMethod httpmethod, final String userData,
                                           final String sshKeyPair, final Map<Long, IpAddresses> requestedIps, final IpAddresses defaultIps, final Boolean displayvm, final
                                           String keyboard, final List<Long> affinityGroupIdList,
                                           final Map<String, String> customParametrs, final String customId) throws InsufficientCapacityException,
        ConcurrentOperationException, ResourceUnavailableException,
        StorageUnavailableException, ResourceAllocationException {

    final Account caller = CallContext.current().getCallingAccount();
    final List<NetworkVO> networkList = new ArrayList<>();

    // Verify that caller can perform actions in behalf of vm owner
    _accountMgr.checkAccess(caller, null, true, owner);

    // Verify that owner can use the service offering
    _accountMgr.checkAccess(owner, serviceOffering);
    _accountMgr.checkAccess(owner, _diskOfferingDao.findById(diskOfferingId));

    checkHypervisorEnabled(zone, template);

    if (networkIdList == null || networkIdList.isEmpty()) {
        throw new InvalidParameterValueException("Please provide at least one network ID");
    }

    final List<HypervisorType> vpcSupportedHTypes = _vpcMgr.getSupportedVpcHypervisors();
    for (final Long networkId : networkIdList) {
        final NetworkVO network = _networkDao.findById(networkId);
        if (network == null) {
            throw new InvalidParameterValueException("Unable to find network by id " + networkIdList.get(0));
        }
        if (Network.GuestType.Private.equals(network.getGuestType())) {
            throw new InvalidParameterValueException("Deploying VMs in a network of type " + Network.GuestType.Private + " is not possible.");
        }
        if (network.getVpcId() != null) {
            // Only ISOs, XenServer, KVM and template types are
            // supported for vpc networks
            if (template.getFormat() != ImageFormat.ISO && !vpcSupportedHTypes.contains(template.getHypervisorType())) {
                throw new InvalidParameterValueException("Can't create vm from template with hypervisor " + template.getHypervisorType() + " in vpc network " + network);
            } else if (template.getFormat() == ImageFormat.ISO && !vpcSupportedHTypes.contains(hypervisor)) {
                // Only XenServer and KVM hypervisors are supported for vpc networks
                throw new InvalidParameterValueException("Can't create vm of hypervisor type " + hypervisor + " in vpc network");
            }
        }

        _networkModel.checkNetworkPermissions(owner, network);

        // don't allow to use system networks
        final NetworkOffering networkOffering = _entityMgr.findById(NetworkOffering.class, network.getNetworkOfferingId());
        if (networkOffering.isSystemOnly()) {
            throw new InvalidParameterValueException("Network id=" + networkId + " is system only and can't be used for vm deployment");
        }
        networkList.add(network);
    }

    return createVirtualMachine(zone, serviceOffering, template, hostName, displayName, owner, diskOfferingId, diskSize, networkList, null, group, httpmethod, userData,
            sshKeyPair, hypervisor, caller, requestedIps, defaultIps, displayvm, keyboard, affinityGroupIdList, customParametrs, customId);
}
 

private String extract(final Account caller, final Long templateId, final String url, final Long zoneId, final String mode, final Long eventId, final boolean isISO) {
    String desc = Upload.Type.TEMPLATE.toString();
    if (isISO) {
        desc = Upload.Type.ISO.toString();
    }
    if (!_accountMgr.isRootAdmin(caller.getId()) && _disableExtraction) {
        throw new PermissionDeniedException("Extraction has been disabled by admin");
    }

    final VMTemplateVO template = _tmpltDao.findById(templateId);
    if (template == null || template.getRemoved() != null) {
        throw new InvalidParameterValueException("Unable to find " + desc + " with id " + templateId);
    }

    if (template.getTemplateType() == Storage.TemplateType.SYSTEM) {
        throw new InvalidParameterValueException("Unable to extract the " + desc + " " + template.getName() + " as it is a default System template");
    } else if (template.getTemplateType() == Storage.TemplateType.PERHOST) {
        throw new InvalidParameterValueException("Unable to extract the " + desc + " " + template.getName() + " as it resides on host and not on SSVM");
    }

    if (isISO) {
        if (template.getFormat() != ImageFormat.ISO) {
            throw new InvalidParameterValueException("Unsupported format, could not extract the ISO");
        }
    } else {
        if (template.getFormat() == ImageFormat.ISO) {
            throw new InvalidParameterValueException("Unsupported format, could not extract the template");
        }
    }

    if (zoneId != null && _dcDao.findById(zoneId) == null) {
        throw new IllegalArgumentException("Please specify a valid zone.");
    }

    if (!_accountMgr.isRootAdmin(caller.getId()) && !template.isExtractable()) {
        throw new InvalidParameterValueException("Unable to extract template id=" + templateId + " as it's not extractable");
    }

    _accountMgr.checkAccess(caller, AccessType.OperateEntry, true, template);

    final List<DataStore> ssStores = _dataStoreMgr.getImageStoresByScope(new ZoneScope(null));

    TemplateDataStoreVO tmpltStoreRef = null;
    ImageStoreEntity tmpltStore = null;
    if (ssStores != null) {
        for (final DataStore store : ssStores) {
            tmpltStoreRef = _tmplStoreDao.findByStoreTemplate(store.getId(), templateId);
            if (tmpltStoreRef != null) {
                if (tmpltStoreRef.getDownloadState() == com.cloud.storage.VMTemplateStorageResourceAssoc.Status.DOWNLOADED) {
                    tmpltStore = (ImageStoreEntity) store;
                    break;
                }
            }
        }
    }

    if (tmpltStore == null) {
        throw new InvalidParameterValueException("The " + desc + " has not been downloaded ");
    }

    // Check if the url already exists
    if (tmpltStoreRef.getExtractUrl() != null) {
        return tmpltStoreRef.getExtractUrl();
    }

    // Handle NFS to S3 object store migration case, we trigger template sync from NFS to S3 during extract template or copy template
    _tmpltSvr.syncTemplateToRegionStore(templateId, tmpltStore);

    final TemplateInfo templateObject = _tmplFactory.getTemplate(templateId, tmpltStore);
    final String extractUrl = tmpltStore.createEntityExtractUrl(templateObject.getInstallPath(), template.getFormat(), templateObject);
    tmpltStoreRef.setExtractUrl(extractUrl);
    tmpltStoreRef.setExtractUrlCreated(DateUtil.now());
    _tmplStoreDao.update(tmpltStoreRef.getId(), tmpltStoreRef);
    return extractUrl;
}
 

@Override
public boolean storagePoolHasEnoughSpace(final List<Volume> volumes, final StoragePool pool) {
    if (volumes == null || volumes.isEmpty()) {
        return false;
    }

    if (!checkUsagedSpace(pool)) {
        return false;
    }

    // allocated space includes template of specified volume
    final StoragePoolVO poolVO = _storagePoolDao.findById(pool.getId());
    long allocatedSizeWithtemplate = _capacityMgr.getAllocatedPoolCapacity(poolVO, null);
    long totalAskingSize = 0;
    for (final Volume volume : volumes) {
        // refreshing the volume from the DB to get latest hv_ss_reserve (hypervisor snapshot reserve) field
        // I could have just assigned this to "volume", but decided to make a new variable for it so that it
        // might be clearer that this "volume" in "volumes" still might have an old value for hv_ss_reverse.
        VolumeVO volumeVO = _volumeDao.findById(volume.getId());

        if (volumeVO.getHypervisorSnapshotReserve() == null) {
            // update the volume's hv_ss_reserve (hypervisor snapshot reserve) from a disk offering (used for managed storage)
            volService.updateHypervisorSnapshotReserveForVolume(getDiskOfferingVO(volumeVO), volumeVO.getId(), getHypervisorType(volumeVO));

            // hv_ss_reserve field might have been updated; refresh from DB to make use of it in getVolumeSizeIncludingHypervisorSnapshotReserve
            volumeVO = _volumeDao.findById(volume.getId());
        }

        if (volumeVO.getTemplateId() != null) {
            final VMTemplateVO tmpl = _templateDao.findByIdIncludingRemoved(volumeVO.getTemplateId());
            if (tmpl != null && tmpl.getFormat() != ImageFormat.ISO) {
                allocatedSizeWithtemplate = _capacityMgr.getAllocatedPoolCapacity(poolVO, tmpl);
            }
        }
        if (volumeVO.getState() != Volume.State.Ready) {
            totalAskingSize = totalAskingSize + getVolumeSizeIncludingHypervisorSnapshotReserve(volumeVO, pool);
        }
    }

    final long totalOverProvCapacity;
    if (pool.getPoolType() == StoragePoolType.NetworkFilesystem || pool.getPoolType() == StoragePoolType.Filesystem) {
        final BigDecimal overProvFactor = getStorageOverProvisioningFactor(pool.getId());
        totalOverProvCapacity = overProvFactor.multiply(new BigDecimal(pool.getCapacityBytes())).longValue();
        s_logger.debug("Found storage pool " + poolVO.getName() + " of type " + pool.getPoolType().toString() + " with overprovisioning factor "
                + overProvFactor.toString());
        s_logger.debug("Total over provisioned capacity calculated is " + overProvFactor + " * " + pool.getCapacityBytes());
    } else {
        totalOverProvCapacity = pool.getCapacityBytes();
        s_logger.debug("Found storage pool " + poolVO.getName() + " of type " + pool.getPoolType().toString());
    }

    s_logger.debug("Total capacity of the pool " + poolVO.getName() + " id: " + pool.getId() + " is " + totalOverProvCapacity);
    final double storageAllocatedThreshold = CapacityManager.StorageAllocatedCapacityDisableThreshold.valueIn(pool.getDataCenterId());
    if (s_logger.isDebugEnabled()) {
        s_logger.debug("Checking pool: " + pool.getId() + " for volume allocation " + volumes.toString() + ", maxSize : " + totalOverProvCapacity +
                ", totalAllocatedSize : " + allocatedSizeWithtemplate + ", askingSize : " + totalAskingSize + ", allocated disable threshold: " +
                storageAllocatedThreshold);
    }

    final double usedPercentage = (allocatedSizeWithtemplate + totalAskingSize) / (double) totalOverProvCapacity;
    if (usedPercentage > storageAllocatedThreshold) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("Insufficient un-allocated capacity on: " + pool.getId() + " for volume allocation: " + volumes.toString() +
                    " since its allocated percentage: " + usedPercentage + " has crossed the allocated pool.storage.allocated.capacity.disablethreshold: " +
                    storageAllocatedThreshold + ", skipping this pool");
        }
        return false;
    }

    if (totalOverProvCapacity < allocatedSizeWithtemplate + totalAskingSize) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("Insufficient un-allocated capacity on: " + pool.getId() + " for volume allocation: " + volumes.toString() +
                    ", not enough storage, maxSize : " + totalOverProvCapacity + ", totalAllocatedSize : " + allocatedSizeWithtemplate + ", askingSize : " +
                    totalAskingSize);
        }
        return false;
    }
    return true;
}