mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
592038a304
Feature spec: https://cwiki.apache.org/confluence/display/CLOUDSTACK/Granular+Resource+Limit+Management Introduces the concept of tagged resource limits for granular resource limit management. Limits can be enforced on accounts and domains for the deployment of entities for a tagged resource. Current tagged resource limits can be used for the following resource types, Host limits - user_vm - cpu - memory Storage limits - volume - primary_storage Following global settings can used to specify tags for which limit needs to be enforced, Host: `resource.limit.host.tags` Storage: `resource.limit.storage.tags` Option for specifying tagged resource limits and viewing tagged resource usage are made available in the UI. Enhances the use of templatetag for VM deployment and template creation Adds option to list service/compute offerings that can be used with a given template. A new parameter named templateid has been added. Adds option to list disk offering with suitability flag for a virtual machine. A new parameter named virtualmachineid has been added to the listDiskOfferings API which when passed returns suitableforvirtualmachine param in the response.
679 lines
33 KiB
Java
679 lines
33 KiB
Java
// 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.
|
|
package com.cloud.api.query;
|
|
|
|
import java.text.DecimalFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.EnumSet;
|
|
import java.util.HashMap;
|
|
import java.util.Hashtable;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import org.apache.cloudstack.api.ApiConstants;
|
|
import org.apache.cloudstack.affinity.AffinityGroupResponse;
|
|
import org.apache.cloudstack.api.ApiConstants.DomainDetails;
|
|
import org.apache.cloudstack.api.ApiConstants.HostDetails;
|
|
import org.apache.cloudstack.api.ApiConstants.VMDetails;
|
|
import org.apache.cloudstack.api.ResponseObject.ResponseView;
|
|
import org.apache.cloudstack.api.response.AccountResponse;
|
|
import org.apache.cloudstack.api.response.AsyncJobResponse;
|
|
import org.apache.cloudstack.api.response.DiskOfferingResponse;
|
|
import org.apache.cloudstack.api.response.DomainResponse;
|
|
import org.apache.cloudstack.api.response.DomainRouterResponse;
|
|
import org.apache.cloudstack.api.response.EventResponse;
|
|
import org.apache.cloudstack.api.response.HostForMigrationResponse;
|
|
import org.apache.cloudstack.api.response.HostResponse;
|
|
import org.apache.cloudstack.api.response.HostTagResponse;
|
|
import org.apache.cloudstack.api.response.ImageStoreResponse;
|
|
import org.apache.cloudstack.api.response.InstanceGroupResponse;
|
|
import org.apache.cloudstack.api.response.ObjectStoreResponse;
|
|
import org.apache.cloudstack.api.response.ProjectAccountResponse;
|
|
import org.apache.cloudstack.api.response.ProjectInvitationResponse;
|
|
import org.apache.cloudstack.api.response.ProjectResponse;
|
|
import org.apache.cloudstack.api.response.ResourceTagResponse;
|
|
import org.apache.cloudstack.api.response.SecurityGroupResponse;
|
|
import org.apache.cloudstack.api.response.ServiceOfferingResponse;
|
|
import org.apache.cloudstack.api.response.SnapshotResponse;
|
|
import org.apache.cloudstack.api.response.StoragePoolResponse;
|
|
import org.apache.cloudstack.api.response.StorageTagResponse;
|
|
import org.apache.cloudstack.api.response.TemplateResponse;
|
|
import org.apache.cloudstack.api.response.UserResponse;
|
|
import org.apache.cloudstack.api.response.UserVmResponse;
|
|
import org.apache.cloudstack.api.response.VolumeResponse;
|
|
import org.apache.cloudstack.api.response.ZoneResponse;
|
|
import org.apache.cloudstack.context.CallContext;
|
|
import org.apache.cloudstack.storage.datastore.db.ObjectStoreVO;
|
|
import org.apache.logging.log4j.Logger;
|
|
import org.apache.logging.log4j.LogManager;
|
|
|
|
import com.cloud.api.ApiDBUtils;
|
|
import com.cloud.api.query.vo.AccountJoinVO;
|
|
import com.cloud.api.query.vo.AffinityGroupJoinVO;
|
|
import com.cloud.api.query.vo.AsyncJobJoinVO;
|
|
import com.cloud.api.query.vo.DataCenterJoinVO;
|
|
import com.cloud.api.query.vo.DiskOfferingJoinVO;
|
|
import com.cloud.api.query.vo.DomainJoinVO;
|
|
import com.cloud.api.query.vo.DomainRouterJoinVO;
|
|
import com.cloud.api.query.vo.EventJoinVO;
|
|
import com.cloud.api.query.vo.HostJoinVO;
|
|
import com.cloud.api.query.vo.HostTagVO;
|
|
import com.cloud.api.query.vo.ImageStoreJoinVO;
|
|
import com.cloud.api.query.vo.InstanceGroupJoinVO;
|
|
import com.cloud.api.query.vo.ProjectAccountJoinVO;
|
|
import com.cloud.api.query.vo.ProjectInvitationJoinVO;
|
|
import com.cloud.api.query.vo.ProjectJoinVO;
|
|
import com.cloud.api.query.vo.ResourceTagJoinVO;
|
|
import com.cloud.api.query.vo.SecurityGroupJoinVO;
|
|
import com.cloud.api.query.vo.ServiceOfferingJoinVO;
|
|
import com.cloud.api.query.vo.SnapshotJoinVO;
|
|
import com.cloud.api.query.vo.StoragePoolJoinVO;
|
|
import com.cloud.api.query.vo.TemplateJoinVO;
|
|
import com.cloud.api.query.vo.UserAccountJoinVO;
|
|
import com.cloud.api.query.vo.UserVmJoinVO;
|
|
import com.cloud.api.query.vo.VolumeJoinVO;
|
|
import com.cloud.configuration.Resource;
|
|
import com.cloud.domain.Domain;
|
|
import com.cloud.storage.Storage.ImageFormat;
|
|
import com.cloud.storage.StoragePoolTagVO;
|
|
import com.cloud.storage.VolumeStats;
|
|
import com.cloud.user.Account;
|
|
|
|
/**
|
|
* Helper class to generate response from DB view VO objects.
|
|
*
|
|
*/
|
|
public class ViewResponseHelper {
|
|
|
|
protected Logger logger = LogManager.getLogger(getClass());
|
|
|
|
public static List<UserResponse> createUserResponse(UserAccountJoinVO... users) {
|
|
return createUserResponse(null, users);
|
|
}
|
|
|
|
public static List<UserResponse> createUserResponse(Long domainId, UserAccountJoinVO... users) {
|
|
List<UserResponse> respList = new ArrayList<UserResponse>();
|
|
for (UserAccountJoinVO vt : users) {
|
|
respList.add(ApiDBUtils.newUserResponse(vt, domainId));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
public static List<EventResponse> createEventResponse(EventJoinVO... events) {
|
|
List<EventResponse> respList = new ArrayList<EventResponse>();
|
|
for (EventJoinVO vt : events) {
|
|
respList.add(ApiDBUtils.newEventResponse(vt));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
public static List<ResourceTagResponse> createResourceTagResponse(boolean keyValueOnly, ResourceTagJoinVO... tags) {
|
|
List<ResourceTagResponse> respList = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTagJoinVO vt : tags) {
|
|
respList.add(ApiDBUtils.newResourceTagResponse(vt, keyValueOnly));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
public static List<InstanceGroupResponse> createInstanceGroupResponse(InstanceGroupJoinVO... groups) {
|
|
List<InstanceGroupResponse> respList = new ArrayList<InstanceGroupResponse>();
|
|
for (InstanceGroupJoinVO vt : groups) {
|
|
respList.add(ApiDBUtils.newInstanceGroupResponse(vt));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
public static List<UserVmResponse> createUserVmResponse(ResponseView view, String objectName, UserVmJoinVO... userVms) {
|
|
return createUserVmResponse(view, objectName, EnumSet.of(VMDetails.all), null, null, userVms);
|
|
}
|
|
|
|
public static List<UserVmResponse> createUserVmResponse(ResponseView view, String objectName, Set<VMDetails> details, UserVmJoinVO... userVms) {
|
|
return createUserVmResponse(view, objectName, details, null, null, userVms);
|
|
}
|
|
|
|
public static List<UserVmResponse> createUserVmResponse(ResponseView view, String objectName, Set<VMDetails> details, Boolean accumulateStats, UserVmJoinVO... userVms) {
|
|
return createUserVmResponse(view, objectName, details, accumulateStats, null, userVms);
|
|
}
|
|
|
|
public static List<UserVmResponse> createUserVmResponse(ResponseView view, String objectName, Set<VMDetails> details, Boolean accumulateStats, Boolean showUserData,
|
|
UserVmJoinVO... userVms) {
|
|
Account caller = CallContext.current().getCallingAccount();
|
|
LinkedHashMap<Long, UserVmResponse> vmDataList = new LinkedHashMap<>();
|
|
// Initialise the vmdatalist with the input data
|
|
|
|
for (UserVmJoinVO userVm : userVms) {
|
|
UserVmResponse userVmData = vmDataList.get(userVm.getId());
|
|
if (userVmData == null) {
|
|
// first time encountering this vm
|
|
userVmData = ApiDBUtils.newUserVmResponse(view, objectName, userVm, details, accumulateStats, showUserData, caller);
|
|
} else{
|
|
// update nics, securitygroups, tags, affinitygroups for 1 to many mapping fields
|
|
userVmData = ApiDBUtils.fillVmDetails(view, userVmData, userVm);
|
|
}
|
|
vmDataList.put(userVm.getId(), userVmData);
|
|
}
|
|
return new ArrayList<UserVmResponse>(vmDataList.values());
|
|
}
|
|
|
|
public static List<DomainRouterResponse> createDomainRouterResponse(DomainRouterJoinVO... routers) {
|
|
Account caller = CallContext.current().getCallingAccount();
|
|
LinkedHashMap<Long, DomainRouterResponse> vrDataList = new LinkedHashMap<>();
|
|
// Initialise the vrdatalist with the input data
|
|
for (DomainRouterJoinVO vr : routers) {
|
|
DomainRouterResponse vrData = vrDataList.get(vr.getId());
|
|
if (vrData == null) {
|
|
// first time encountering this vm
|
|
vrData = ApiDBUtils.newDomainRouterResponse(vr, caller);
|
|
} else {
|
|
// update nics for 1 to many mapping fields
|
|
vrData = ApiDBUtils.fillRouterDetails(vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getId(), vrData);
|
|
}
|
|
return new ArrayList<DomainRouterResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<SecurityGroupResponse> createSecurityGroupResponses(List<SecurityGroupJoinVO> securityGroups) {
|
|
Account caller = CallContext.current().getCallingAccount();
|
|
LinkedHashMap<Long, SecurityGroupResponse> vrDataList = new LinkedHashMap<>();
|
|
// Initialise the vrdatalist with the input data
|
|
for (SecurityGroupJoinVO vr : securityGroups) {
|
|
SecurityGroupResponse vrData = vrDataList.get(vr.getId());
|
|
if (vrData == null) {
|
|
// first time encountering this sg
|
|
vrData = ApiDBUtils.newSecurityGroupResponse(vr, caller);
|
|
|
|
} else {
|
|
// update rules for 1 to many mapping fields
|
|
vrData = ApiDBUtils.fillSecurityGroupDetails(vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getId(), vrData);
|
|
}
|
|
return new ArrayList<SecurityGroupResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<ProjectResponse> createProjectResponse(EnumSet<DomainDetails> details, ProjectJoinVO... projects) {
|
|
LinkedHashMap<Long, ProjectResponse> prjDataList = new LinkedHashMap<>();
|
|
// Initialise the prjdatalist with the input data
|
|
for (ProjectJoinVO p : projects) {
|
|
ProjectResponse pData = prjDataList.get(p.getId());
|
|
if (pData == null) {
|
|
// first time encountering this vm
|
|
pData = ApiDBUtils.newProjectResponse(details, p);
|
|
prjDataList.put(p.getId(), pData);
|
|
}
|
|
}
|
|
return new ArrayList<ProjectResponse>(prjDataList.values());
|
|
}
|
|
|
|
public static List<ProjectAccountResponse> createProjectAccountResponse(ProjectAccountJoinVO... projectAccounts) {
|
|
List<ProjectAccountResponse> responseList = new ArrayList<ProjectAccountResponse>();
|
|
for (ProjectAccountJoinVO proj : projectAccounts) {
|
|
ProjectAccountResponse resp = ApiDBUtils.newProjectAccountResponse(proj);
|
|
// update user list
|
|
Account caller = CallContext.current().getCallingAccount();
|
|
if (ApiDBUtils.isAdmin(caller)) {
|
|
List<UserAccountJoinVO> users = null;
|
|
if (proj.getUserUuid() != null) {
|
|
users = Collections.singletonList(ApiDBUtils.findUserAccountById(proj.getUserId()));
|
|
} else {
|
|
users = ApiDBUtils.findUserViewByAccountId(proj.getAccountId());
|
|
}
|
|
resp.setUsers(ViewResponseHelper.createUserResponse(users.toArray(new UserAccountJoinVO[users.size()])));
|
|
}
|
|
responseList.add(resp);
|
|
}
|
|
return responseList;
|
|
}
|
|
|
|
public static List<ProjectInvitationResponse> createProjectInvitationResponse(ProjectInvitationJoinVO... invites) {
|
|
List<ProjectInvitationResponse> respList = new ArrayList<ProjectInvitationResponse>();
|
|
for (ProjectInvitationJoinVO v : invites) {
|
|
respList.add(ApiDBUtils.newProjectInvitationResponse(v));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
public static List<HostResponse> createHostResponse(EnumSet<HostDetails> details, HostJoinVO... hosts) {
|
|
LinkedHashMap<Long, HostResponse> vrDataList = new LinkedHashMap<>();
|
|
// Initialise the vrdatalist with the input data
|
|
for (HostJoinVO vr : hosts) {
|
|
HostResponse vrData = ApiDBUtils.newHostResponse(vr, details);
|
|
vrDataList.put(vr.getId(), vrData);
|
|
}
|
|
return new ArrayList<HostResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<HostForMigrationResponse> createHostForMigrationResponse(EnumSet<HostDetails> details, HostJoinVO... hosts) {
|
|
LinkedHashMap<Long, HostForMigrationResponse> vrDataList = new LinkedHashMap<>();
|
|
// Initialise the vrdatalist with the input data
|
|
for (HostJoinVO vr : hosts) {
|
|
HostForMigrationResponse vrData = ApiDBUtils.newHostForMigrationResponse(vr, details);
|
|
vrDataList.put(vr.getId(), vrData);
|
|
}
|
|
return new ArrayList<HostForMigrationResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<VolumeResponse> createVolumeResponse(ResponseView view, VolumeJoinVO... volumes) {
|
|
LinkedHashMap<Long, VolumeResponse> vrDataList = new LinkedHashMap<>();
|
|
DecimalFormat df = new DecimalFormat("0.0%");
|
|
for (VolumeJoinVO vr : volumes) {
|
|
VolumeResponse vrData = vrDataList.get(vr.getId());
|
|
if (vrData == null) {
|
|
// first time encountering this volume
|
|
vrData = ApiDBUtils.newVolumeResponse(view, vr);
|
|
}
|
|
else{
|
|
// update tags
|
|
vrData = ApiDBUtils.fillVolumeDetails(view, vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getId(), vrData);
|
|
|
|
VolumeStats vs = null;
|
|
if (vr.getFormat() == ImageFormat.VHD || vr.getFormat() == ImageFormat.QCOW2 || vr.getFormat() == ImageFormat.RAW) {
|
|
if (vrData.getPath() != null) {
|
|
vs = ApiDBUtils.getVolumeStatistics(vrData.getPath());
|
|
}
|
|
} else if (vr.getFormat() == ImageFormat.OVA) {
|
|
if (vrData.getChainInfo() != null) {
|
|
vs = ApiDBUtils.getVolumeStatistics(vrData.getChainInfo());
|
|
}
|
|
}
|
|
|
|
if (vs != null) {
|
|
long vsz = vs.getVirtualSize();
|
|
long psz = vs.getPhysicalSize() ;
|
|
double util = (double)psz/vsz;
|
|
vrData.setUtilization(df.format(util));
|
|
|
|
if (view == ResponseView.Full) {
|
|
vrData.setVirtualsize(vsz);
|
|
vrData.setPhysicalsize(psz);
|
|
}
|
|
}
|
|
}
|
|
return new ArrayList<VolumeResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<StoragePoolResponse> createStoragePoolResponse(StoragePoolJoinVO... pools) {
|
|
LinkedHashMap<Long, StoragePoolResponse> vrDataList = new LinkedHashMap<>();
|
|
// Initialise the vrdatalist with the input data
|
|
for (StoragePoolJoinVO vr : pools) {
|
|
StoragePoolResponse vrData = vrDataList.get(vr.getId());
|
|
if (vrData == null) {
|
|
// first time encountering this vm
|
|
vrData = ApiDBUtils.newStoragePoolResponse(vr);
|
|
} else {
|
|
// update tags
|
|
vrData = ApiDBUtils.fillStoragePoolDetails(vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getId(), vrData);
|
|
}
|
|
return new ArrayList<StoragePoolResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<StorageTagResponse> createStorageTagResponse(StoragePoolTagVO... storageTags) {
|
|
ArrayList<StorageTagResponse> list = new ArrayList<StorageTagResponse>();
|
|
|
|
for (StoragePoolTagVO vr : storageTags) {
|
|
list.add(ApiDBUtils.newStorageTagResponse(vr));
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static List<HostTagResponse> createHostTagResponse(HostTagVO... hostTags) {
|
|
ArrayList<HostTagResponse> list = new ArrayList<HostTagResponse>();
|
|
|
|
for (HostTagVO vr : hostTags) {
|
|
list.add(ApiDBUtils.newHostTagResponse(vr));
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public static List<ImageStoreResponse> createImageStoreResponse(ImageStoreJoinVO... stores) {
|
|
LinkedHashMap<Long, ImageStoreResponse> vrDataList = new LinkedHashMap<>();
|
|
// Initialise the vrdatalist with the input data
|
|
for (ImageStoreJoinVO vr : stores) {
|
|
ImageStoreResponse vrData = vrDataList.get(vr.getId());
|
|
if (vrData == null) {
|
|
// first time encountering this vm
|
|
vrData = ApiDBUtils.newImageStoreResponse(vr);
|
|
} else {
|
|
// update tags
|
|
vrData = ApiDBUtils.fillImageStoreDetails(vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getId(), vrData);
|
|
}
|
|
return new ArrayList<ImageStoreResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<StoragePoolResponse> createStoragePoolForMigrationResponse(StoragePoolJoinVO... pools) {
|
|
LinkedHashMap<Long, StoragePoolResponse> vrDataList = new LinkedHashMap<>();
|
|
// Initialise the vrdatalist with the input data
|
|
for (StoragePoolJoinVO vr : pools) {
|
|
StoragePoolResponse vrData = vrDataList.get(vr.getId());
|
|
if (vrData == null) {
|
|
// first time encountering this vm
|
|
vrData = ApiDBUtils.newStoragePoolForMigrationResponse(vr);
|
|
} else {
|
|
// update tags
|
|
vrData = ApiDBUtils.fillStoragePoolForMigrationDetails(vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getId(), vrData);
|
|
}
|
|
return new ArrayList<StoragePoolResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<DomainResponse> createDomainResponse(ResponseView view, EnumSet<DomainDetails> details, List<DomainJoinVO> domains) {
|
|
List<DomainResponse> respList = new ArrayList<DomainResponse>();
|
|
//-- Coping the list to keep original order
|
|
List<DomainJoinVO> domainsCopy = new ArrayList<>(domains);
|
|
Collections.sort(domainsCopy, DomainJoinVO.domainIdComparator);
|
|
for (DomainJoinVO domainJoinVO : domains){
|
|
//-- Set parent information
|
|
DomainJoinVO parentDomainJoinVO = searchParentDomainUsingBinary(domainsCopy, domainJoinVO);
|
|
if(parentDomainJoinVO == null && domainJoinVO.getParent() != null) {
|
|
//-- fetch the parent from the database
|
|
parentDomainJoinVO = ApiDBUtils.findDomainJoinVOById(domainJoinVO.getParent());
|
|
if(parentDomainJoinVO != null) {
|
|
//-- Add parent domain to the domain copy for future use
|
|
domainsCopy.add(parentDomainJoinVO);
|
|
Collections.sort(domainsCopy, DomainJoinVO.domainIdComparator);
|
|
}
|
|
}
|
|
if(parentDomainJoinVO != null) {
|
|
domainJoinVO.setParentName(parentDomainJoinVO.getName());
|
|
domainJoinVO.setParentUuid(parentDomainJoinVO.getUuid());
|
|
}
|
|
//-- Set correct resource limits
|
|
if(domainJoinVO.getParent() != null && domainJoinVO.getParent() != Domain.ROOT_DOMAIN) {
|
|
Map<Resource.ResourceType, Long> resourceLimitMap = new HashMap<>();
|
|
copyResourceLimitsIntoMap(resourceLimitMap, domainJoinVO);
|
|
//-- Fetching the parent domain resource limit if absent in current domain
|
|
setParentResourceLimitIfNeeded(resourceLimitMap, domainJoinVO, domainsCopy);
|
|
//-- copy the final correct resource limit
|
|
copyResourceLimitsFromMap(resourceLimitMap, domainJoinVO);
|
|
}
|
|
respList.add(ApiDBUtils.newDomainResponse(view, details, domainJoinVO));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
private static DomainJoinVO searchParentDomainUsingBinary(List<DomainJoinVO> domainsCopy, DomainJoinVO domainJoinVO){
|
|
Long parentId = domainJoinVO.getParent() == null ? 0 : domainJoinVO.getParent();
|
|
int totalDomains = domainsCopy.size();
|
|
int left = 0;
|
|
int right = totalDomains -1;
|
|
while(left <= right){
|
|
int middle = (left + right) /2;
|
|
DomainJoinVO middleObject = domainsCopy.get(middle);
|
|
if(middleObject.getId() == parentId){
|
|
return middleObject;
|
|
}
|
|
if(middleObject.getId() > parentId){
|
|
right = middle - 1 ;
|
|
}
|
|
else{
|
|
left = middle + 1;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static void copyResourceLimitsIntoMap(Map<Resource.ResourceType, Long> resourceLimitMap, DomainJoinVO domainJoinVO){
|
|
resourceLimitMap.put(Resource.ResourceType.user_vm, domainJoinVO.getVmLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.public_ip, domainJoinVO.getIpLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.volume, domainJoinVO.getVolumeLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.snapshot, domainJoinVO.getSnapshotLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.template, domainJoinVO.getTemplateLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.network, domainJoinVO.getNetworkLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.vpc, domainJoinVO.getVpcLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.cpu, domainJoinVO.getCpuLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.memory, domainJoinVO.getMemoryLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.primary_storage, domainJoinVO.getPrimaryStorageLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.secondary_storage, domainJoinVO.getSecondaryStorageLimit());
|
|
resourceLimitMap.put(Resource.ResourceType.project, domainJoinVO.getProjectLimit());
|
|
}
|
|
|
|
private static void copyResourceLimitsFromMap(Map<Resource.ResourceType, Long> resourceLimitMap, DomainJoinVO domainJoinVO){
|
|
domainJoinVO.setVmLimit(resourceLimitMap.get(Resource.ResourceType.user_vm));
|
|
domainJoinVO.setIpLimit(resourceLimitMap.get(Resource.ResourceType.public_ip));
|
|
domainJoinVO.setVolumeLimit(resourceLimitMap.get(Resource.ResourceType.volume));
|
|
domainJoinVO.setSnapshotLimit(resourceLimitMap.get(Resource.ResourceType.snapshot));
|
|
domainJoinVO.setTemplateLimit(resourceLimitMap.get(Resource.ResourceType.template));
|
|
domainJoinVO.setNetworkLimit(resourceLimitMap.get(Resource.ResourceType.network));
|
|
domainJoinVO.setVpcLimit(resourceLimitMap.get(Resource.ResourceType.vpc));
|
|
domainJoinVO.setCpuLimit(resourceLimitMap.get(Resource.ResourceType.cpu));
|
|
domainJoinVO.setMemoryLimit(resourceLimitMap.get(Resource.ResourceType.memory));
|
|
domainJoinVO.setPrimaryStorageLimit(resourceLimitMap.get(Resource.ResourceType.primary_storage));
|
|
domainJoinVO.setSecondaryStorageLimit(resourceLimitMap.get(Resource.ResourceType.secondary_storage));
|
|
domainJoinVO.setProjectLimit(resourceLimitMap.get(Resource.ResourceType.project));
|
|
}
|
|
|
|
private static void setParentResourceLimitIfNeeded(Map<Resource.ResourceType, Long> resourceLimitMap, DomainJoinVO domainJoinVO, List<DomainJoinVO> domainsCopy) {
|
|
DomainJoinVO parentDomainJoinVO = searchParentDomainUsingBinary(domainsCopy, domainJoinVO);
|
|
|
|
if(parentDomainJoinVO != null) {
|
|
Long vmLimit = resourceLimitMap.get(Resource.ResourceType.user_vm);
|
|
Long ipLimit = resourceLimitMap.get(Resource.ResourceType.public_ip);
|
|
Long volumeLimit = resourceLimitMap.get(Resource.ResourceType.volume);
|
|
Long snapshotLimit = resourceLimitMap.get(Resource.ResourceType.snapshot);
|
|
Long templateLimit = resourceLimitMap.get(Resource.ResourceType.template);
|
|
Long networkLimit = resourceLimitMap.get(Resource.ResourceType.network);
|
|
Long vpcLimit = resourceLimitMap.get(Resource.ResourceType.vpc);
|
|
Long cpuLimit = resourceLimitMap.get(Resource.ResourceType.cpu);
|
|
Long memoryLimit = resourceLimitMap.get(Resource.ResourceType.memory);
|
|
Long primaryStorageLimit = resourceLimitMap.get(Resource.ResourceType.primary_storage);
|
|
Long secondaryStorageLimit = resourceLimitMap.get(Resource.ResourceType.secondary_storage);
|
|
Long projectLimit = resourceLimitMap.get(Resource.ResourceType.project);
|
|
|
|
if (vmLimit == null) {
|
|
vmLimit = parentDomainJoinVO.getVmLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.user_vm, vmLimit);
|
|
}
|
|
if (ipLimit == null) {
|
|
ipLimit = parentDomainJoinVO.getIpLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.public_ip, ipLimit);
|
|
}
|
|
if (volumeLimit == null) {
|
|
volumeLimit = parentDomainJoinVO.getVolumeLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.volume, volumeLimit);
|
|
}
|
|
if (snapshotLimit == null) {
|
|
snapshotLimit = parentDomainJoinVO.getSnapshotLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.snapshot, snapshotLimit);
|
|
}
|
|
if (templateLimit == null) {
|
|
templateLimit = parentDomainJoinVO.getTemplateLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.template, templateLimit);
|
|
}
|
|
if (networkLimit == null) {
|
|
networkLimit = parentDomainJoinVO.getNetworkLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.network, networkLimit);
|
|
}
|
|
if (vpcLimit == null) {
|
|
vpcLimit = parentDomainJoinVO.getVpcLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.vpc, vpcLimit);
|
|
}
|
|
if (cpuLimit == null) {
|
|
cpuLimit = parentDomainJoinVO.getCpuLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.cpu, cpuLimit);
|
|
}
|
|
if (memoryLimit == null) {
|
|
memoryLimit = parentDomainJoinVO.getMemoryLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.memory, memoryLimit);
|
|
}
|
|
if (primaryStorageLimit == null) {
|
|
primaryStorageLimit = parentDomainJoinVO.getPrimaryStorageLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.primary_storage, primaryStorageLimit);
|
|
}
|
|
if (secondaryStorageLimit == null) {
|
|
secondaryStorageLimit = parentDomainJoinVO.getSecondaryStorageLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.secondary_storage, secondaryStorageLimit);
|
|
}
|
|
if (projectLimit == null) {
|
|
projectLimit = parentDomainJoinVO.getProjectLimit();
|
|
resourceLimitMap.put(Resource.ResourceType.project, projectLimit);
|
|
}
|
|
//-- try till parent present
|
|
if (parentDomainJoinVO.getParent() != null && parentDomainJoinVO.getParent() != Domain.ROOT_DOMAIN) {
|
|
setParentResourceLimitIfNeeded(resourceLimitMap, parentDomainJoinVO, domainsCopy);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static List<AccountResponse> createAccountResponse(ResponseView view, EnumSet<DomainDetails> details, AccountJoinVO... accounts) {
|
|
List<AccountResponse> respList = new ArrayList<AccountResponse>();
|
|
for (AccountJoinVO vt : accounts){
|
|
respList.add(ApiDBUtils.newAccountResponse(view, details, vt));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
public static List<AsyncJobResponse> createAsyncJobResponse(AsyncJobJoinVO... jobs) {
|
|
List<AsyncJobResponse> respList = new ArrayList<AsyncJobResponse>();
|
|
for (AsyncJobJoinVO vt : jobs) {
|
|
respList.add(ApiDBUtils.newAsyncJobResponse(vt));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
public static List<DiskOfferingResponse> createDiskOfferingResponses(Long vmId, List<DiskOfferingJoinVO> offerings) {
|
|
return ApiDBUtils.newDiskOfferingResponses(vmId, offerings);
|
|
}
|
|
|
|
public static List<ServiceOfferingResponse> createServiceOfferingResponse(ServiceOfferingJoinVO... offerings) {
|
|
List<ServiceOfferingResponse> respList = new ArrayList<ServiceOfferingResponse>();
|
|
for (ServiceOfferingJoinVO vt : offerings) {
|
|
respList.add(ApiDBUtils.newServiceOfferingResponse(vt));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
public static List<ZoneResponse> createDataCenterResponse(ResponseView view, Boolean showCapacities, Boolean showResourceImage, DataCenterJoinVO... dcs) {
|
|
List<ZoneResponse> respList = new ArrayList<ZoneResponse>();
|
|
for (DataCenterJoinVO vt : dcs){
|
|
respList.add(ApiDBUtils.newDataCenterResponse(view, vt, showCapacities, showResourceImage));
|
|
}
|
|
return respList;
|
|
}
|
|
|
|
public static List<TemplateResponse> createTemplateResponse(EnumSet<ApiConstants.DomainDetails> detailsView, ResponseView view, TemplateJoinVO... templates) {
|
|
LinkedHashMap<String, TemplateResponse> vrDataList = new LinkedHashMap<>();
|
|
for (TemplateJoinVO vr : templates) {
|
|
TemplateResponse vrData = vrDataList.get(vr.getTempZonePair());
|
|
if (vrData == null) {
|
|
// first time encountering this volume
|
|
vrData = ApiDBUtils.newTemplateResponse(detailsView, view, vr);
|
|
}
|
|
else{
|
|
// update tags
|
|
vrData = ApiDBUtils.fillTemplateDetails(detailsView, view, vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getTempZonePair(), vrData);
|
|
}
|
|
return new ArrayList<TemplateResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<SnapshotResponse> createSnapshotResponse(ResponseView view, boolean isShowUnique, SnapshotJoinVO... snapshots) {
|
|
LinkedHashMap<String, SnapshotResponse> vrDataList = new LinkedHashMap<>();
|
|
for (SnapshotJoinVO vr : snapshots) {
|
|
SnapshotResponse vrData = vrDataList.get(vr.getSnapshotStorePair());
|
|
if (vrData == null) {
|
|
// first time encountering this snapshot
|
|
vrData = ApiDBUtils.newSnapshotResponse(view, isShowUnique, vr);
|
|
}
|
|
else{
|
|
// update tags
|
|
vrData = ApiDBUtils.fillSnapshotDetails(vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getSnapshotStorePair(), vrData);
|
|
}
|
|
return new ArrayList<SnapshotResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<TemplateResponse> createTemplateUpdateResponse(ResponseView view, TemplateJoinVO... templates) {
|
|
LinkedHashMap<Long, TemplateResponse> vrDataList = new LinkedHashMap<>();
|
|
for (TemplateJoinVO vr : templates) {
|
|
TemplateResponse vrData = vrDataList.get(vr.getId());
|
|
if (vrData == null) {
|
|
// first time encountering this volume
|
|
vrData = ApiDBUtils.newTemplateUpdateResponse(vr);
|
|
} else {
|
|
// update tags
|
|
vrData = ApiDBUtils.fillTemplateDetails(EnumSet.of(DomainDetails.all), view, vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getId(), vrData);
|
|
}
|
|
return new ArrayList<TemplateResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<TemplateResponse> createIsoResponse(ResponseView view, TemplateJoinVO... templates) {
|
|
LinkedHashMap<String, TemplateResponse> vrDataList = new LinkedHashMap<>();
|
|
for (TemplateJoinVO vr : templates) {
|
|
TemplateResponse vrData = vrDataList.get(vr.getTempZonePair());
|
|
if (vrData == null) {
|
|
// first time encountering this volume
|
|
vrData = ApiDBUtils.newIsoResponse(vr, view);
|
|
} else {
|
|
// update tags
|
|
vrData = ApiDBUtils.fillTemplateDetails(EnumSet.of(DomainDetails.all), view, vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getTempZonePair(), vrData);
|
|
}
|
|
return new ArrayList<TemplateResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<AffinityGroupResponse> createAffinityGroupResponses(List<AffinityGroupJoinVO> groups) {
|
|
LinkedHashMap<Long, AffinityGroupResponse> vrDataList = new LinkedHashMap<>();
|
|
for (AffinityGroupJoinVO vr : groups) {
|
|
AffinityGroupResponse vrData = vrDataList.get(vr.getId());
|
|
if (vrData == null) {
|
|
// first time encountering this AffinityGroup
|
|
vrData = ApiDBUtils.newAffinityGroupResponse(vr);
|
|
} else {
|
|
// update vms
|
|
vrData = ApiDBUtils.fillAffinityGroupDetails(vrData, vr);
|
|
}
|
|
vrDataList.put(vr.getId(), vrData);
|
|
}
|
|
return new ArrayList<AffinityGroupResponse>(vrDataList.values());
|
|
}
|
|
|
|
public static List<ObjectStoreResponse> createObjectStoreResponse(ObjectStoreVO[] stores) {
|
|
Hashtable<Long, ObjectStoreResponse> storeList = new Hashtable<Long, ObjectStoreResponse>();
|
|
// Initialise the storeList with the input data
|
|
for (ObjectStoreVO store : stores) {
|
|
ObjectStoreResponse storeData = storeList.get(store.getId());
|
|
if (storeData == null) {
|
|
// first time encountering this store
|
|
storeData = ApiDBUtils.newObjectStoreResponse(store);
|
|
} else {
|
|
// update tags
|
|
storeData = ApiDBUtils.fillObjectStoreDetails(storeData, store);
|
|
}
|
|
storeList.put(store.getId(), storeData);
|
|
}
|
|
return new ArrayList<>(storeList.values());
|
|
}
|
|
}
|