mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
f46651e672
This PR adds an ability to Pass a new parameter, locationType,
to the “createSnapshot” API command. Depending on the locationType,
we decide where the snapshot should go in case of managed storage.
There are two possible values for the locationType param
1) `Standard`: The standard operation for managed storage is to
keep the snapshot on the device. For non-managed storage, this will
be to upload it to secondary storage. This option will be the
default.
2) `Archive`: Applicable only to managed storage. This will
keep the snapshot on the secondary storage. For non-managed
storage, this will result in an error.
The reason for implementing this feature is to avoid a single
point of failure for primary storage. Right now in case of managed
storage, if the primary storage goes down, there is no easy way
to recover data as all snapshots are also stored on the primary.
This features allows us to mitigate that risk.
1969 lines
76 KiB
Java
1969 lines
76 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;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.EnumSet;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.ListIterator;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import javax.annotation.PostConstruct;
|
|
import javax.inject.Inject;
|
|
|
|
import org.apache.cloudstack.acl.Role;
|
|
import org.apache.cloudstack.acl.RoleService;
|
|
import org.apache.cloudstack.affinity.AffinityGroup;
|
|
import org.apache.cloudstack.affinity.AffinityGroupResponse;
|
|
import org.apache.cloudstack.affinity.dao.AffinityGroupDao;
|
|
import org.apache.cloudstack.api.ApiCommandJobType;
|
|
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.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.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.engine.orchestration.service.NetworkOrchestrationService;
|
|
import org.apache.cloudstack.engine.orchestration.service.VolumeOrchestrationService;
|
|
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
|
|
import org.apache.cloudstack.framework.jobs.AsyncJob;
|
|
import org.apache.cloudstack.framework.jobs.AsyncJobManager;
|
|
import org.apache.cloudstack.framework.jobs.dao.AsyncJobDao;
|
|
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
|
|
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
|
|
|
|
import com.cloud.agent.api.VgpuTypesInfo;
|
|
import com.cloud.api.query.dao.AccountJoinDao;
|
|
import com.cloud.api.query.dao.AffinityGroupJoinDao;
|
|
import com.cloud.api.query.dao.AsyncJobJoinDao;
|
|
import com.cloud.api.query.dao.DataCenterJoinDao;
|
|
import com.cloud.api.query.dao.DiskOfferingJoinDao;
|
|
import com.cloud.api.query.dao.DomainJoinDao;
|
|
import com.cloud.api.query.dao.DomainRouterJoinDao;
|
|
import com.cloud.api.query.dao.HostJoinDao;
|
|
import com.cloud.api.query.dao.HostTagDao;
|
|
import com.cloud.api.query.dao.ImageStoreJoinDao;
|
|
import com.cloud.api.query.dao.InstanceGroupJoinDao;
|
|
import com.cloud.api.query.dao.ProjectAccountJoinDao;
|
|
import com.cloud.api.query.dao.ProjectInvitationJoinDao;
|
|
import com.cloud.api.query.dao.ProjectJoinDao;
|
|
import com.cloud.api.query.dao.ResourceTagJoinDao;
|
|
import com.cloud.api.query.dao.SecurityGroupJoinDao;
|
|
import com.cloud.api.query.dao.ServiceOfferingJoinDao;
|
|
import com.cloud.api.query.dao.StoragePoolJoinDao;
|
|
import com.cloud.api.query.dao.StorageTagDao;
|
|
import com.cloud.api.query.dao.TemplateJoinDao;
|
|
import com.cloud.api.query.dao.UserAccountJoinDao;
|
|
import com.cloud.api.query.dao.UserVmJoinDao;
|
|
import com.cloud.api.query.dao.VolumeJoinDao;
|
|
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.StoragePoolJoinVO;
|
|
import com.cloud.api.query.vo.StorageTagVO;
|
|
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.capacity.CapacityManager;
|
|
import com.cloud.capacity.CapacityVO;
|
|
import com.cloud.capacity.dao.CapacityDao;
|
|
import com.cloud.capacity.dao.CapacityDaoImpl.SummedCapacity;
|
|
import com.cloud.configuration.Config;
|
|
import com.cloud.configuration.ConfigurationManager;
|
|
import com.cloud.configuration.ConfigurationService;
|
|
import com.cloud.configuration.Resource;
|
|
import com.cloud.configuration.Resource.ResourceType;
|
|
import com.cloud.dc.AccountVlanMapVO;
|
|
import com.cloud.dc.ClusterDetailsDao;
|
|
import com.cloud.dc.ClusterDetailsVO;
|
|
import com.cloud.dc.ClusterVO;
|
|
import com.cloud.dc.DataCenter;
|
|
import com.cloud.dc.DataCenterVO;
|
|
import com.cloud.dc.HostPodVO;
|
|
import com.cloud.dc.Vlan;
|
|
import com.cloud.dc.VlanVO;
|
|
import com.cloud.dc.dao.AccountVlanMapDao;
|
|
import com.cloud.dc.dao.ClusterDao;
|
|
import com.cloud.dc.dao.DataCenterDao;
|
|
import com.cloud.dc.dao.HostPodDao;
|
|
import com.cloud.dc.dao.VlanDao;
|
|
import com.cloud.domain.Domain;
|
|
import com.cloud.domain.DomainVO;
|
|
import com.cloud.domain.dao.DomainDao;
|
|
import com.cloud.event.Event;
|
|
import com.cloud.event.dao.EventJoinDao;
|
|
import com.cloud.exception.InvalidParameterValueException;
|
|
import com.cloud.gpu.HostGpuGroupsVO;
|
|
import com.cloud.gpu.VGPUTypesVO;
|
|
import com.cloud.gpu.dao.HostGpuGroupsDao;
|
|
import com.cloud.gpu.dao.VGPUTypesDao;
|
|
import com.cloud.ha.HighAvailabilityManager;
|
|
import com.cloud.host.Host;
|
|
import com.cloud.host.HostStats;
|
|
import com.cloud.host.HostVO;
|
|
import com.cloud.host.dao.HostDao;
|
|
import com.cloud.host.dao.HostDetailsDao;
|
|
import com.cloud.hypervisor.Hypervisor.HypervisorType;
|
|
import com.cloud.network.IpAddress;
|
|
import com.cloud.network.Network;
|
|
import com.cloud.network.Network.Capability;
|
|
import com.cloud.network.Network.Provider;
|
|
import com.cloud.network.Network.Service;
|
|
import com.cloud.network.NetworkModel;
|
|
import com.cloud.network.NetworkProfile;
|
|
import com.cloud.network.Networks.TrafficType;
|
|
import com.cloud.network.PhysicalNetworkServiceProvider;
|
|
import com.cloud.network.as.AutoScalePolicy;
|
|
import com.cloud.network.as.AutoScalePolicyConditionMapVO;
|
|
import com.cloud.network.as.AutoScalePolicyVO;
|
|
import com.cloud.network.as.AutoScaleVmGroupPolicyMapVO;
|
|
import com.cloud.network.as.AutoScaleVmGroupVO;
|
|
import com.cloud.network.as.AutoScaleVmProfileVO;
|
|
import com.cloud.network.as.ConditionVO;
|
|
import com.cloud.network.as.CounterVO;
|
|
import com.cloud.network.as.dao.AutoScalePolicyConditionMapDao;
|
|
import com.cloud.network.as.dao.AutoScalePolicyDao;
|
|
import com.cloud.network.as.dao.AutoScaleVmGroupDao;
|
|
import com.cloud.network.as.dao.AutoScaleVmGroupPolicyMapDao;
|
|
import com.cloud.network.as.dao.AutoScaleVmProfileDao;
|
|
import com.cloud.network.as.dao.ConditionDao;
|
|
import com.cloud.network.as.dao.CounterDao;
|
|
import com.cloud.network.dao.AccountGuestVlanMapDao;
|
|
import com.cloud.network.dao.AccountGuestVlanMapVO;
|
|
import com.cloud.network.dao.FirewallRulesCidrsDao;
|
|
import com.cloud.network.dao.FirewallRulesDao;
|
|
import com.cloud.network.dao.IPAddressDao;
|
|
import com.cloud.network.dao.IPAddressVO;
|
|
import com.cloud.network.dao.LoadBalancerDao;
|
|
import com.cloud.network.dao.LoadBalancerVO;
|
|
import com.cloud.network.dao.NetworkDao;
|
|
import com.cloud.network.dao.NetworkDomainDao;
|
|
import com.cloud.network.dao.NetworkDomainVO;
|
|
import com.cloud.network.dao.NetworkRuleConfigDao;
|
|
import com.cloud.network.dao.NetworkRuleConfigVO;
|
|
import com.cloud.network.dao.NetworkVO;
|
|
import com.cloud.network.dao.PhysicalNetworkDao;
|
|
import com.cloud.network.dao.PhysicalNetworkServiceProviderDao;
|
|
import com.cloud.network.dao.PhysicalNetworkServiceProviderVO;
|
|
import com.cloud.network.dao.PhysicalNetworkTrafficTypeDao;
|
|
import com.cloud.network.dao.PhysicalNetworkTrafficTypeVO;
|
|
import com.cloud.network.dao.PhysicalNetworkVO;
|
|
import com.cloud.network.dao.Site2SiteCustomerGatewayDao;
|
|
import com.cloud.network.dao.Site2SiteCustomerGatewayVO;
|
|
import com.cloud.network.dao.Site2SiteVpnGatewayDao;
|
|
import com.cloud.network.dao.Site2SiteVpnGatewayVO;
|
|
import com.cloud.network.router.VirtualRouter;
|
|
import com.cloud.network.rules.FirewallRuleVO;
|
|
import com.cloud.network.rules.LoadBalancer;
|
|
import com.cloud.network.security.SecurityGroup;
|
|
import com.cloud.network.security.SecurityGroupManager;
|
|
import com.cloud.network.security.SecurityGroupVO;
|
|
import com.cloud.network.security.dao.SecurityGroupDao;
|
|
import com.cloud.network.vpc.NetworkACL;
|
|
import com.cloud.network.vpc.StaticRouteVO;
|
|
import com.cloud.network.vpc.VpcGatewayVO;
|
|
import com.cloud.network.vpc.VpcManager;
|
|
import com.cloud.network.vpc.VpcOffering;
|
|
import com.cloud.network.vpc.VpcProvisioningService;
|
|
import com.cloud.network.vpc.VpcVO;
|
|
import com.cloud.network.vpc.dao.NetworkACLDao;
|
|
import com.cloud.network.vpc.dao.StaticRouteDao;
|
|
import com.cloud.network.vpc.dao.VpcDao;
|
|
import com.cloud.network.vpc.dao.VpcGatewayDao;
|
|
import com.cloud.network.vpc.dao.VpcOfferingDao;
|
|
import com.cloud.offering.DiskOffering;
|
|
import com.cloud.offering.ServiceOffering;
|
|
import com.cloud.offerings.NetworkOfferingVO;
|
|
import com.cloud.offerings.dao.NetworkOfferingDao;
|
|
import com.cloud.projects.Project;
|
|
import com.cloud.projects.ProjectAccount;
|
|
import com.cloud.projects.ProjectInvitation;
|
|
import com.cloud.projects.ProjectService;
|
|
import com.cloud.region.ha.GlobalLoadBalancingRulesService;
|
|
import com.cloud.resource.ResourceManager;
|
|
import com.cloud.server.ManagementServer;
|
|
import com.cloud.server.ResourceMetaDataService;
|
|
import com.cloud.server.ResourceTag;
|
|
import com.cloud.server.ResourceTag.ResourceObjectType;
|
|
import com.cloud.server.StatsCollector;
|
|
import com.cloud.server.TaggedResourceService;
|
|
import com.cloud.service.ServiceOfferingDetailsVO;
|
|
import com.cloud.service.ServiceOfferingVO;
|
|
import com.cloud.service.dao.ServiceOfferingDao;
|
|
import com.cloud.service.dao.ServiceOfferingDetailsDao;
|
|
import com.cloud.storage.DiskOfferingVO;
|
|
import com.cloud.storage.GuestOS;
|
|
import com.cloud.storage.GuestOSCategoryVO;
|
|
import com.cloud.storage.ImageStore;
|
|
import com.cloud.storage.Snapshot;
|
|
import com.cloud.storage.SnapshotVO;
|
|
import com.cloud.storage.Storage.ImageFormat;
|
|
import com.cloud.storage.Storage.StoragePoolType;
|
|
import com.cloud.storage.StorageManager;
|
|
import com.cloud.storage.StoragePool;
|
|
import com.cloud.storage.StorageStats;
|
|
import com.cloud.storage.UploadVO;
|
|
import com.cloud.storage.VMTemplateVO;
|
|
import com.cloud.storage.Volume;
|
|
import com.cloud.storage.Volume.Type;
|
|
import com.cloud.storage.VolumeVO;
|
|
import com.cloud.storage.dao.DiskOfferingDao;
|
|
import com.cloud.storage.dao.GuestOSCategoryDao;
|
|
import com.cloud.storage.dao.GuestOSDao;
|
|
import com.cloud.storage.dao.SnapshotDao;
|
|
import com.cloud.storage.dao.SnapshotPolicyDao;
|
|
import com.cloud.storage.dao.UploadDao;
|
|
import com.cloud.storage.dao.VMTemplateDao;
|
|
import com.cloud.storage.dao.VMTemplateDetailsDao;
|
|
import com.cloud.storage.dao.VolumeDao;
|
|
import com.cloud.storage.snapshot.SnapshotPolicy;
|
|
import com.cloud.template.TemplateManager;
|
|
import com.cloud.template.VirtualMachineTemplate;
|
|
import com.cloud.user.Account;
|
|
import com.cloud.user.AccountDetailsDao;
|
|
import com.cloud.user.AccountService;
|
|
import com.cloud.user.AccountVO;
|
|
import com.cloud.user.ResourceLimitService;
|
|
import com.cloud.user.SSHKeyPairVO;
|
|
import com.cloud.user.User;
|
|
import com.cloud.user.UserAccount;
|
|
import com.cloud.user.UserStatisticsVO;
|
|
import com.cloud.user.UserVO;
|
|
import com.cloud.user.dao.AccountDao;
|
|
import com.cloud.user.dao.SSHKeyPairDao;
|
|
import com.cloud.user.dao.UserDao;
|
|
import com.cloud.user.dao.UserStatisticsDao;
|
|
import com.cloud.uservm.UserVm;
|
|
import com.cloud.utils.EnumUtils;
|
|
import com.cloud.utils.NumbersUtil;
|
|
import com.cloud.utils.Pair;
|
|
import com.cloud.vm.ConsoleProxyVO;
|
|
import com.cloud.vm.DomainRouterVO;
|
|
import com.cloud.vm.InstanceGroup;
|
|
import com.cloud.vm.InstanceGroupVO;
|
|
import com.cloud.vm.NicProfile;
|
|
import com.cloud.vm.UserVmDetailVO;
|
|
import com.cloud.vm.UserVmManager;
|
|
import com.cloud.vm.UserVmVO;
|
|
import com.cloud.vm.VMInstanceVO;
|
|
import com.cloud.vm.VirtualMachine;
|
|
import com.cloud.vm.VmStats;
|
|
import com.cloud.vm.dao.ConsoleProxyDao;
|
|
import com.cloud.vm.dao.DomainRouterDao;
|
|
import com.cloud.vm.dao.NicSecondaryIpDao;
|
|
import com.cloud.vm.dao.NicSecondaryIpVO;
|
|
import com.cloud.vm.dao.UserVmDao;
|
|
import com.cloud.vm.dao.UserVmDetailsDao;
|
|
import com.cloud.vm.dao.VMInstanceDao;
|
|
import com.cloud.vm.snapshot.VMSnapshot;
|
|
import com.cloud.vm.snapshot.dao.VMSnapshotDao;
|
|
|
|
public class ApiDBUtils {
|
|
private static ManagementServer s_ms;
|
|
static AsyncJobManager s_asyncMgr;
|
|
static SecurityGroupManager s_securityGroupMgr;
|
|
static StorageManager s_storageMgr;
|
|
static VolumeOrchestrationService s_volumeMgr;
|
|
static UserVmManager s_userVmMgr;
|
|
static NetworkModel s_networkModel;
|
|
static NetworkOrchestrationService s_networkMgr;
|
|
static TemplateManager s_templateMgr;
|
|
static ConfigurationManager s_configMgr;
|
|
|
|
static StatsCollector s_statsCollector;
|
|
|
|
static AccountDao s_accountDao;
|
|
static AccountVlanMapDao s_accountVlanMapDao;
|
|
static ClusterDao s_clusterDao;
|
|
static CapacityDao s_capacityDao;
|
|
static DiskOfferingDao s_diskOfferingDao;
|
|
static DiskOfferingJoinDao s_diskOfferingJoinDao;
|
|
static DataCenterJoinDao s_dcJoinDao;
|
|
static DomainDao s_domainDao;
|
|
static DomainJoinDao s_domainJoinDao;
|
|
static DomainRouterDao s_domainRouterDao;
|
|
static DomainRouterJoinDao s_domainRouterJoinDao;
|
|
static GuestOSDao s_guestOSDao;
|
|
static GuestOSCategoryDao s_guestOSCategoryDao;
|
|
static HostDao s_hostDao;
|
|
static AccountGuestVlanMapDao s_accountGuestVlanMapDao;
|
|
static IPAddressDao s_ipAddressDao;
|
|
static LoadBalancerDao s_loadBalancerDao;
|
|
static SecurityGroupDao s_securityGroupDao;
|
|
static SecurityGroupJoinDao s_securityGroupJoinDao;
|
|
static ServiceOfferingJoinDao s_serviceOfferingJoinDao;
|
|
static NetworkRuleConfigDao s_networkRuleConfigDao;
|
|
static HostPodDao s_podDao;
|
|
static ServiceOfferingDao s_serviceOfferingDao;
|
|
static ServiceOfferingDetailsDao s_serviceOfferingDetailsDao;
|
|
static SnapshotDao s_snapshotDao;
|
|
static PrimaryDataStoreDao s_storagePoolDao;
|
|
static VMTemplateDao s_templateDao;
|
|
static VMTemplateDetailsDao s_templateDetailsDao;
|
|
static UploadDao s_uploadDao;
|
|
static UserDao s_userDao;
|
|
static UserStatisticsDao s_userStatsDao;
|
|
static UserVmDao s_userVmDao;
|
|
static UserVmJoinDao s_userVmJoinDao;
|
|
static VlanDao s_vlanDao;
|
|
static VolumeDao s_volumeDao;
|
|
static Site2SiteVpnGatewayDao s_site2SiteVpnGatewayDao;
|
|
static Site2SiteCustomerGatewayDao s_site2SiteCustomerGatewayDao;
|
|
static DataCenterDao s_zoneDao;
|
|
static NetworkOfferingDao s_networkOfferingDao;
|
|
static NetworkDao s_networkDao;
|
|
static PhysicalNetworkDao s_physicalNetworkDao;
|
|
static ConfigurationService s_configSvc;
|
|
static ConfigurationDao s_configDao;
|
|
static ConsoleProxyDao s_consoleProxyDao;
|
|
static FirewallRulesCidrsDao s_firewallCidrsDao;
|
|
static VMInstanceDao s_vmDao;
|
|
static ResourceLimitService s_resourceLimitMgr;
|
|
static ProjectService s_projectMgr;
|
|
static ResourceManager s_resourceMgr;
|
|
static AccountDetailsDao s_accountDetailsDao;
|
|
static NetworkDomainDao s_networkDomainDao;
|
|
static HighAvailabilityManager s_haMgr;
|
|
static VpcManager s_vpcMgr;
|
|
static TaggedResourceService s_taggedResourceService;
|
|
static UserVmDetailsDao s_userVmDetailsDao;
|
|
static SSHKeyPairDao s_sshKeyPairDao;
|
|
|
|
static ConditionDao s_asConditionDao;
|
|
static AutoScalePolicyConditionMapDao s_asPolicyConditionMapDao;
|
|
static AutoScaleVmGroupPolicyMapDao s_asVmGroupPolicyMapDao;
|
|
static AutoScalePolicyDao s_asPolicyDao;
|
|
static AutoScaleVmProfileDao s_asVmProfileDao;
|
|
static AutoScaleVmGroupDao s_asVmGroupDao;
|
|
static CounterDao s_counterDao;
|
|
static ResourceTagJoinDao s_tagJoinDao;
|
|
static EventJoinDao s_eventJoinDao;
|
|
static InstanceGroupJoinDao s_vmGroupJoinDao;
|
|
static UserAccountJoinDao s_userAccountJoinDao;
|
|
static ProjectJoinDao s_projectJoinDao;
|
|
static ProjectAccountJoinDao s_projectAccountJoinDao;
|
|
static ProjectInvitationJoinDao s_projectInvitationJoinDao;
|
|
static HostJoinDao s_hostJoinDao;
|
|
static VolumeJoinDao s_volJoinDao;
|
|
static StoragePoolJoinDao s_poolJoinDao;
|
|
static StorageTagDao s_tagDao;
|
|
static HostTagDao s_hostTagDao;
|
|
static ImageStoreJoinDao s_imageStoreJoinDao;
|
|
static AccountJoinDao s_accountJoinDao;
|
|
static AsyncJobJoinDao s_jobJoinDao;
|
|
static TemplateJoinDao s_templateJoinDao;
|
|
|
|
static PhysicalNetworkTrafficTypeDao s_physicalNetworkTrafficTypeDao;
|
|
static PhysicalNetworkServiceProviderDao s_physicalNetworkServiceProviderDao;
|
|
static FirewallRulesDao s_firewallRuleDao;
|
|
static StaticRouteDao s_staticRouteDao;
|
|
static VpcGatewayDao s_vpcGatewayDao;
|
|
static VpcDao s_vpcDao;
|
|
static VpcOfferingDao s_vpcOfferingDao;
|
|
static SnapshotPolicyDao s_snapshotPolicyDao;
|
|
static AsyncJobDao s_asyncJobDao;
|
|
static HostDetailsDao s_hostDetailsDao;
|
|
static VMSnapshotDao s_vmSnapshotDao;
|
|
static ClusterDetailsDao s_clusterDetailsDao;
|
|
static NicSecondaryIpDao s_nicSecondaryIpDao;
|
|
static VpcProvisioningService s_vpcProvSvc;
|
|
static AffinityGroupDao s_affinityGroupDao;
|
|
static AffinityGroupJoinDao s_affinityGroupJoinDao;
|
|
static GlobalLoadBalancingRulesService s_gslbService;
|
|
static NetworkACLDao s_networkACLDao;
|
|
static RoleService s_roleService;
|
|
static AccountService s_accountService;
|
|
static ResourceMetaDataService s_resourceDetailsService;
|
|
static HostGpuGroupsDao s_hostGpuGroupsDao;
|
|
static VGPUTypesDao s_vgpuTypesDao;
|
|
|
|
@Inject
|
|
private ManagementServer ms;
|
|
@Inject
|
|
public AsyncJobManager asyncMgr;
|
|
@Inject
|
|
private SecurityGroupManager securityGroupMgr;
|
|
@Inject
|
|
private StorageManager storageMgr;
|
|
@Inject
|
|
private UserVmManager userVmMgr;
|
|
@Inject
|
|
private NetworkModel networkModel;
|
|
@Inject
|
|
private NetworkOrchestrationService networkMgr;
|
|
@Inject
|
|
private StatsCollector statsCollector;
|
|
@Inject
|
|
private TemplateManager templateMgr;
|
|
@Inject
|
|
private VolumeOrchestrationService volumeMgr;
|
|
|
|
@Inject
|
|
private AccountDao accountDao;
|
|
@Inject
|
|
private AccountVlanMapDao accountVlanMapDao;
|
|
@Inject
|
|
private ClusterDao clusterDao;
|
|
@Inject
|
|
private CapacityDao capacityDao;
|
|
@Inject
|
|
private DataCenterJoinDao dcJoinDao;
|
|
@Inject
|
|
private DiskOfferingDao diskOfferingDao;
|
|
@Inject
|
|
private DiskOfferingJoinDao diskOfferingJoinDao;
|
|
@Inject
|
|
private DomainDao domainDao;
|
|
@Inject
|
|
private DomainJoinDao domainJoinDao;
|
|
@Inject
|
|
private DomainRouterDao domainRouterDao;
|
|
@Inject
|
|
private DomainRouterJoinDao domainRouterJoinDao;
|
|
@Inject
|
|
private GuestOSDao guestOSDao;
|
|
@Inject
|
|
private GuestOSCategoryDao guestOSCategoryDao;
|
|
@Inject
|
|
private HostDao hostDao;
|
|
@Inject
|
|
private AccountGuestVlanMapDao accountGuestVlanMapDao;
|
|
@Inject
|
|
private IPAddressDao ipAddressDao;
|
|
@Inject
|
|
private LoadBalancerDao loadBalancerDao;
|
|
@Inject
|
|
private SecurityGroupDao securityGroupDao;
|
|
@Inject
|
|
private SecurityGroupJoinDao securityGroupJoinDao;
|
|
@Inject
|
|
private ServiceOfferingJoinDao serviceOfferingJoinDao;
|
|
@Inject
|
|
private NetworkRuleConfigDao networkRuleConfigDao;
|
|
@Inject
|
|
private HostPodDao podDao;
|
|
@Inject
|
|
private ServiceOfferingDao serviceOfferingDao;
|
|
@Inject
|
|
private ServiceOfferingDetailsDao serviceOfferingDetailsDao;
|
|
@Inject
|
|
private SnapshotDao snapshotDao;
|
|
@Inject
|
|
private PrimaryDataStoreDao storagePoolDao;
|
|
@Inject
|
|
private VMTemplateDao templateDao;
|
|
@Inject
|
|
private VMTemplateDetailsDao templateDetailsDao;
|
|
@Inject
|
|
private UploadDao uploadDao;
|
|
@Inject
|
|
private UserDao userDao;
|
|
@Inject
|
|
private UserStatisticsDao userStatsDao;
|
|
@Inject
|
|
private UserVmDao userVmDao;
|
|
@Inject
|
|
private UserVmJoinDao userVmJoinDao;
|
|
@Inject
|
|
private VlanDao vlanDao;
|
|
@Inject
|
|
private VolumeDao volumeDao;
|
|
@Inject
|
|
private Site2SiteVpnGatewayDao site2SiteVpnGatewayDao;
|
|
@Inject
|
|
private Site2SiteCustomerGatewayDao site2SiteCustomerGatewayDao;
|
|
@Inject
|
|
private DataCenterDao zoneDao;
|
|
@Inject
|
|
private NetworkOfferingDao networkOfferingDao;
|
|
@Inject
|
|
private NetworkDao networkDao;
|
|
@Inject
|
|
private PhysicalNetworkDao physicalNetworkDao;
|
|
@Inject
|
|
private ConfigurationService configSvc;
|
|
@Inject
|
|
private ConfigurationDao configDao;
|
|
@Inject
|
|
private ConsoleProxyDao consoleProxyDao;
|
|
@Inject
|
|
private FirewallRulesCidrsDao firewallCidrsDao;
|
|
@Inject
|
|
private VMInstanceDao vmDao;
|
|
@Inject
|
|
private ResourceLimitService resourceLimitMgr;
|
|
@Inject
|
|
private ProjectService projectMgr;
|
|
@Inject
|
|
private ResourceManager resourceMgr;
|
|
@Inject
|
|
private AccountDetailsDao accountDetailsDao;
|
|
@Inject
|
|
private NetworkDomainDao networkDomainDao;
|
|
@Inject
|
|
private HighAvailabilityManager haMgr;
|
|
@Inject
|
|
private VpcManager vpcMgr;
|
|
@Inject
|
|
private TaggedResourceService taggedResourceService;
|
|
@Inject
|
|
private UserVmDetailsDao userVmDetailsDao;
|
|
@Inject
|
|
private SSHKeyPairDao sshKeyPairDao;
|
|
|
|
@Inject
|
|
private ConditionDao asConditionDao;
|
|
@Inject
|
|
private AutoScalePolicyConditionMapDao asPolicyConditionMapDao;
|
|
@Inject
|
|
private AutoScaleVmGroupPolicyMapDao asVmGroupPolicyMapDao;
|
|
@Inject
|
|
private AutoScalePolicyDao asPolicyDao;
|
|
@Inject
|
|
private AutoScaleVmProfileDao asVmProfileDao;
|
|
@Inject
|
|
private AutoScaleVmGroupDao asVmGroupDao;
|
|
@Inject
|
|
private CounterDao counterDao;
|
|
@Inject
|
|
private ResourceTagJoinDao tagJoinDao;
|
|
@Inject
|
|
private EventJoinDao eventJoinDao;
|
|
@Inject
|
|
private InstanceGroupJoinDao vmGroupJoinDao;
|
|
@Inject
|
|
private UserAccountJoinDao userAccountJoinDao;
|
|
@Inject
|
|
private ProjectJoinDao projectJoinDao;
|
|
@Inject
|
|
private ProjectAccountJoinDao projectAccountJoinDao;
|
|
@Inject
|
|
private ProjectInvitationJoinDao projectInvitationJoinDao;
|
|
@Inject
|
|
private HostJoinDao hostJoinDao;
|
|
@Inject
|
|
private VolumeJoinDao volJoinDao;
|
|
@Inject
|
|
private StoragePoolJoinDao poolJoinDao;
|
|
@Inject
|
|
private StorageTagDao tagDao;
|
|
@Inject
|
|
private HostTagDao hosttagDao;
|
|
@Inject
|
|
private ImageStoreJoinDao imageStoreJoinDao;
|
|
@Inject
|
|
private AccountJoinDao accountJoinDao;
|
|
@Inject
|
|
private AsyncJobJoinDao jobJoinDao;
|
|
@Inject
|
|
private TemplateJoinDao templateJoinDao;
|
|
|
|
@Inject
|
|
private PhysicalNetworkTrafficTypeDao physicalNetworkTrafficTypeDao;
|
|
@Inject
|
|
private PhysicalNetworkServiceProviderDao physicalNetworkServiceProviderDao;
|
|
@Inject
|
|
private FirewallRulesDao firewallRuleDao;
|
|
@Inject
|
|
private StaticRouteDao staticRouteDao;
|
|
@Inject
|
|
private VpcGatewayDao vpcGatewayDao;
|
|
@Inject
|
|
private VpcDao vpcDao;
|
|
@Inject
|
|
private VpcOfferingDao vpcOfferingDao;
|
|
@Inject
|
|
private SnapshotPolicyDao snapshotPolicyDao;
|
|
@Inject
|
|
private AsyncJobDao asyncJobDao;
|
|
@Inject
|
|
private HostDetailsDao hostDetailsDao;
|
|
@Inject
|
|
private ClusterDetailsDao clusterDetailsDao;
|
|
@Inject
|
|
private VMSnapshotDao vmSnapshotDao;
|
|
@Inject
|
|
private NicSecondaryIpDao nicSecondaryIpDao;
|
|
@Inject
|
|
private VpcProvisioningService vpcProvSvc;
|
|
@Inject
|
|
private AffinityGroupDao affinityGroupDao;
|
|
@Inject
|
|
private AffinityGroupJoinDao affinityGroupJoinDao;
|
|
@Inject
|
|
private GlobalLoadBalancingRulesService gslbService;
|
|
@Inject
|
|
private NetworkACLDao networkACLDao;
|
|
@Inject
|
|
private RoleService roleService;
|
|
@Inject
|
|
private AccountService accountService;
|
|
@Inject
|
|
private ConfigurationManager configMgr;
|
|
@Inject
|
|
private ResourceMetaDataService resourceDetailsService;
|
|
@Inject
|
|
private HostGpuGroupsDao hostGpuGroupsDao;
|
|
@Inject
|
|
private VGPUTypesDao vgpuTypesDao;
|
|
|
|
@PostConstruct
|
|
void init() {
|
|
s_ms = ms;
|
|
s_configMgr = configMgr;
|
|
s_asyncMgr = asyncMgr;
|
|
s_securityGroupMgr = securityGroupMgr;
|
|
s_storageMgr = storageMgr;
|
|
s_userVmMgr = userVmMgr;
|
|
s_networkModel = networkModel;
|
|
s_networkMgr = networkMgr;
|
|
s_configSvc = configSvc;
|
|
s_templateMgr = templateMgr;
|
|
|
|
s_accountDao = accountDao;
|
|
s_accountGuestVlanMapDao = accountGuestVlanMapDao;
|
|
s_accountVlanMapDao = accountVlanMapDao;
|
|
s_clusterDao = clusterDao;
|
|
s_capacityDao = capacityDao;
|
|
s_dcJoinDao = dcJoinDao;
|
|
s_diskOfferingDao = diskOfferingDao;
|
|
s_diskOfferingJoinDao = diskOfferingJoinDao;
|
|
s_domainDao = domainDao;
|
|
s_domainJoinDao = domainJoinDao;
|
|
s_domainRouterDao = domainRouterDao;
|
|
s_domainRouterJoinDao = domainRouterJoinDao;
|
|
s_guestOSDao = guestOSDao;
|
|
s_guestOSCategoryDao = guestOSCategoryDao;
|
|
s_hostDao = hostDao;
|
|
s_ipAddressDao = ipAddressDao;
|
|
s_loadBalancerDao = loadBalancerDao;
|
|
s_networkRuleConfigDao = networkRuleConfigDao;
|
|
s_podDao = podDao;
|
|
s_serviceOfferingDao = serviceOfferingDao;
|
|
s_serviceOfferingDetailsDao = serviceOfferingDetailsDao;
|
|
s_serviceOfferingJoinDao = serviceOfferingJoinDao;
|
|
s_snapshotDao = snapshotDao;
|
|
s_storagePoolDao = storagePoolDao;
|
|
s_templateDao = templateDao;
|
|
s_templateDetailsDao = templateDetailsDao;
|
|
s_uploadDao = uploadDao;
|
|
s_userDao = userDao;
|
|
s_userStatsDao = userStatsDao;
|
|
s_userVmDao = userVmDao;
|
|
s_userVmJoinDao = userVmJoinDao;
|
|
s_vlanDao = vlanDao;
|
|
s_volumeDao = volumeDao;
|
|
s_site2SiteVpnGatewayDao = site2SiteVpnGatewayDao;
|
|
s_site2SiteCustomerGatewayDao = site2SiteCustomerGatewayDao;
|
|
s_zoneDao = zoneDao;
|
|
s_securityGroupDao = securityGroupDao;
|
|
s_securityGroupJoinDao = securityGroupJoinDao;
|
|
s_networkOfferingDao = networkOfferingDao;
|
|
s_networkDao = networkDao;
|
|
s_physicalNetworkDao = physicalNetworkDao;
|
|
s_configDao = configDao;
|
|
s_consoleProxyDao = consoleProxyDao;
|
|
s_firewallCidrsDao = firewallCidrsDao;
|
|
s_vmDao = vmDao;
|
|
s_resourceLimitMgr = resourceLimitMgr;
|
|
s_projectMgr = projectMgr;
|
|
s_resourceMgr = resourceMgr;
|
|
s_accountDetailsDao = accountDetailsDao;
|
|
s_networkDomainDao = networkDomainDao;
|
|
s_haMgr = haMgr;
|
|
s_vpcMgr = vpcMgr;
|
|
s_taggedResourceService = taggedResourceService;
|
|
s_sshKeyPairDao = sshKeyPairDao;
|
|
s_userVmDetailsDao = userVmDetailsDao;
|
|
s_asConditionDao = asConditionDao;
|
|
s_asPolicyDao = asPolicyDao;
|
|
s_asPolicyConditionMapDao = asPolicyConditionMapDao;
|
|
s_counterDao = counterDao;
|
|
s_asVmGroupPolicyMapDao = asVmGroupPolicyMapDao;
|
|
s_tagJoinDao = tagJoinDao;
|
|
s_vmGroupJoinDao = vmGroupJoinDao;
|
|
s_eventJoinDao = eventJoinDao;
|
|
s_userAccountJoinDao = userAccountJoinDao;
|
|
s_projectJoinDao = projectJoinDao;
|
|
s_projectAccountJoinDao = projectAccountJoinDao;
|
|
s_projectInvitationJoinDao = projectInvitationJoinDao;
|
|
s_hostJoinDao = hostJoinDao;
|
|
s_volJoinDao = volJoinDao;
|
|
s_poolJoinDao = poolJoinDao;
|
|
s_tagDao = tagDao;
|
|
s_hostTagDao = hosttagDao;
|
|
s_imageStoreJoinDao = imageStoreJoinDao;
|
|
s_accountJoinDao = accountJoinDao;
|
|
s_jobJoinDao = jobJoinDao;
|
|
s_templateJoinDao = templateJoinDao;
|
|
|
|
s_physicalNetworkTrafficTypeDao = physicalNetworkTrafficTypeDao;
|
|
s_physicalNetworkServiceProviderDao = physicalNetworkServiceProviderDao;
|
|
s_firewallRuleDao = firewallRuleDao;
|
|
s_staticRouteDao = staticRouteDao;
|
|
s_vpcGatewayDao = vpcGatewayDao;
|
|
s_asVmProfileDao = asVmProfileDao;
|
|
s_asVmGroupDao = asVmGroupDao;
|
|
s_vpcDao = vpcDao;
|
|
s_vpcOfferingDao = vpcOfferingDao;
|
|
s_snapshotPolicyDao = snapshotPolicyDao;
|
|
s_asyncJobDao = asyncJobDao;
|
|
s_hostDetailsDao = hostDetailsDao;
|
|
s_clusterDetailsDao = clusterDetailsDao;
|
|
s_vmSnapshotDao = vmSnapshotDao;
|
|
s_nicSecondaryIpDao = nicSecondaryIpDao;
|
|
s_vpcProvSvc = vpcProvSvc;
|
|
s_affinityGroupDao = affinityGroupDao;
|
|
s_affinityGroupJoinDao = affinityGroupJoinDao;
|
|
s_gslbService = gslbService;
|
|
// Note: stats collector should already have been initialized by this time, otherwise a null instance is returned
|
|
s_statsCollector = StatsCollector.getInstance();
|
|
s_networkACLDao = networkACLDao;
|
|
s_roleService = roleService;
|
|
s_accountService = accountService;
|
|
s_resourceDetailsService = resourceDetailsService;
|
|
s_hostGpuGroupsDao = hostGpuGroupsDao;
|
|
s_vgpuTypesDao = vgpuTypesDao;
|
|
}
|
|
|
|
// ///////////////////////////////////////////////////////////
|
|
// ManagementServer methods //
|
|
// ///////////////////////////////////////////////////////////
|
|
|
|
public static VMInstanceVO findVMInstanceById(long vmId) {
|
|
return s_vmDao.findByIdIncludingRemoved(vmId);
|
|
}
|
|
|
|
public static long getStorageCapacitybyPool(Long poolId, short capacityType) {
|
|
// TODO: This method is for the API only, but it has configuration values (ramSize for system vms)
|
|
// so if this Utils class can have some kind of config rather than a static initializer (maybe from
|
|
// management server instantiation?) then maybe the management server method can be moved entirely
|
|
// into this utils class.
|
|
return s_ms.getMemoryOrCpuCapacityByHost(poolId, capacityType);
|
|
}
|
|
|
|
public static List<SummedCapacity> getCapacityByClusterPodZone(Long zoneId, Long podId, Long clusterId) {
|
|
return s_capacityDao.findByClusterPodZone(zoneId, podId, clusterId);
|
|
}
|
|
|
|
public static List<SummedCapacity> findNonSharedStorageForClusterPodZone(Long zoneId, Long podId, Long clusterId) {
|
|
return s_capacityDao.findNonSharedStorageForClusterPodZone(zoneId, podId, clusterId);
|
|
}
|
|
|
|
public static List<CapacityVO> getCapacityByPod() {
|
|
return null;
|
|
|
|
}
|
|
|
|
public static Long getPodIdForVlan(long vlanDbId) {
|
|
return s_networkModel.getPodIdForVlan(vlanDbId);
|
|
}
|
|
|
|
public static String getVersion() {
|
|
return s_ms.getVersion();
|
|
}
|
|
|
|
|
|
// ///////////////////////////////////////////////////////////
|
|
// Manager methods //
|
|
// ///////////////////////////////////////////////////////////
|
|
|
|
public static long findCorrectResourceLimitForDomain(ResourceType type, long domainId) {
|
|
DomainVO domain = s_domainDao.findById(domainId);
|
|
|
|
if (domain == null) {
|
|
return -1;
|
|
}
|
|
|
|
return s_resourceLimitMgr.findCorrectResourceLimitForDomain(domain, type);
|
|
}
|
|
|
|
public static long findCorrectResourceLimitForDomain(Long limit, boolean isRootDomain, ResourceType type, long domainId) {
|
|
long max = Resource.RESOURCE_UNLIMITED; // if resource limit is not found, then we treat it as unlimited
|
|
|
|
// No limits for Root domain
|
|
if (isRootDomain) {
|
|
return max;
|
|
}
|
|
if (limit != null) {
|
|
return limit.longValue();
|
|
} else {
|
|
return findCorrectResourceLimitForDomain(type, domainId);
|
|
}
|
|
}
|
|
|
|
public static long findCorrectResourceLimit(ResourceType type, long accountId) {
|
|
AccountVO account = s_accountDao.findById(accountId);
|
|
|
|
if (account == null) {
|
|
return -1;
|
|
}
|
|
|
|
return s_resourceLimitMgr.findCorrectResourceLimitForAccount(account, type);
|
|
}
|
|
|
|
public static long findCorrectResourceLimit(Long limit, long accountId, ResourceType type) {
|
|
return s_resourceLimitMgr.findCorrectResourceLimitForAccount(accountId, limit, type);
|
|
}
|
|
|
|
public static long getResourceCount(ResourceType type, long accountId) {
|
|
AccountVO account = s_accountDao.findById(accountId);
|
|
|
|
if (account == null) {
|
|
return -1;
|
|
}
|
|
|
|
return s_resourceLimitMgr.getResourceCount(account, type);
|
|
}
|
|
|
|
public static String getSecurityGroupsNamesForVm(long vmId) {
|
|
return s_securityGroupMgr.getSecurityGroupsNamesForVm(vmId);
|
|
}
|
|
|
|
public static List<SecurityGroupVO> getSecurityGroupsForVm(long vmId) {
|
|
return s_securityGroupMgr.getSecurityGroupsForVm(vmId);
|
|
}
|
|
|
|
public static String getSnapshotIntervalTypes(long snapshotId) {
|
|
SnapshotVO snapshot = s_snapshotDao.findById(snapshotId);
|
|
return snapshot.getRecurringType().name();
|
|
}
|
|
|
|
public static String getSnapshotLocationType(long snapshotId) {
|
|
SnapshotVO snapshot = s_snapshotDao.findById(snapshotId);
|
|
|
|
return snapshot.getLocationType() != null ? snapshot.getLocationType().name() : null;
|
|
}
|
|
|
|
public static String getStoragePoolTags(long poolId) {
|
|
return s_storageMgr.getStoragePoolTags(poolId);
|
|
}
|
|
|
|
public static boolean isLocalStorageActiveOnHost(Long hostId) {
|
|
return s_storageMgr.isLocalStorageActiveOnHost(hostId);
|
|
}
|
|
|
|
public static InstanceGroupVO findInstanceGroupForVM(long vmId) {
|
|
return s_userVmMgr.getGroupForVm(vmId);
|
|
}
|
|
|
|
// ///////////////////////////////////////////////////////////
|
|
// Misc methods //
|
|
// ///////////////////////////////////////////////////////////
|
|
|
|
public static HostStats getHostStatistics(long hostId) {
|
|
return s_statsCollector.getHostStats(hostId);
|
|
}
|
|
|
|
public static StorageStats getStoragePoolStatistics(long id) {
|
|
return s_statsCollector.getStoragePoolStats(id);
|
|
}
|
|
|
|
public static VmStats getVmStatistics(long hostId) {
|
|
return s_statsCollector.getVmStats(hostId);
|
|
}
|
|
|
|
public static StorageStats getSecondaryStorageStatistics(long id) {
|
|
return s_statsCollector.getStorageStats(id);
|
|
}
|
|
|
|
public static CapacityVO getStoragePoolUsedStats(Long poolId, Long clusterId, Long podId, Long zoneId) {
|
|
return s_storageMgr.getStoragePoolUsedStats(poolId, clusterId, podId, zoneId);
|
|
}
|
|
|
|
public static CapacityVO getSecondaryStorageUsedStats(Long hostId, Long zoneId) {
|
|
return s_storageMgr.getSecondaryStorageUsedStats(hostId, zoneId);
|
|
}
|
|
|
|
// ///////////////////////////////////////////////////////////
|
|
// Dao methods //
|
|
// ///////////////////////////////////////////////////////////
|
|
|
|
public static Account findAccountById(Long accountId) {
|
|
return s_accountDao.findByIdIncludingRemoved(accountId);
|
|
}
|
|
|
|
public static Account findAccountByIdIncludingRemoved(Long accountId) {
|
|
return s_accountDao.findByIdIncludingRemoved(accountId);
|
|
}
|
|
|
|
public static Account findAccountByNameDomain(String accountName, Long domainId) {
|
|
return s_accountDao.findActiveAccount(accountName, domainId);
|
|
}
|
|
|
|
public static ClusterVO findClusterById(long clusterId) {
|
|
return s_clusterDao.findById(clusterId);
|
|
}
|
|
|
|
public static String findClusterDetails(long clusterId, String name) {
|
|
ClusterDetailsVO detailsVO = s_clusterDetailsDao.findDetail(clusterId, name);
|
|
if (detailsVO != null) {
|
|
return detailsVO.getValue();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static DiskOfferingVO findDiskOfferingById(Long diskOfferingId) {
|
|
DiskOfferingVO off = s_diskOfferingDao.findByIdIncludingRemoved(diskOfferingId);
|
|
if (off.getType() == DiskOfferingVO.Type.Disk) {
|
|
return off;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static DomainVO findDomainById(Long domainId) {
|
|
return s_domainDao.findByIdIncludingRemoved(domainId);
|
|
}
|
|
|
|
public static DomainVO findDomainByIdIncludingRemoved(Long domainId) {
|
|
return s_domainDao.findByIdIncludingRemoved(domainId);
|
|
}
|
|
|
|
public static boolean isChildDomain(long parentId, long childId) {
|
|
return s_domainDao.isChildDomain(parentId, childId);
|
|
}
|
|
|
|
public static DomainRouterVO findDomainRouterById(Long routerId) {
|
|
return s_domainRouterDao.findByIdIncludingRemoved(routerId);
|
|
}
|
|
|
|
public static GuestOS findGuestOSById(Long id) {
|
|
return s_guestOSDao.findByIdIncludingRemoved(id);
|
|
}
|
|
|
|
public static GuestOS findGuestOSByDisplayName(String displayName) {
|
|
return s_guestOSDao.listByDisplayName(displayName);
|
|
}
|
|
|
|
public static HostVO findHostById(Long hostId) {
|
|
return s_hostDao.findByIdIncludingRemoved(hostId);
|
|
}
|
|
|
|
public static IPAddressVO findIpAddressById(long addressId) {
|
|
return s_ipAddressDao.findById(addressId);
|
|
}
|
|
|
|
public static GuestOSCategoryVO getHostGuestOSCategory(long hostId) {
|
|
Long guestOSCategoryID = s_resourceMgr.getGuestOSCategoryId(hostId);
|
|
|
|
if (guestOSCategoryID != null) {
|
|
return s_guestOSCategoryDao.findById(guestOSCategoryID);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static String getHostTags(long hostId) {
|
|
return s_resourceMgr.getHostTags(hostId);
|
|
}
|
|
|
|
public static LoadBalancerVO findLoadBalancerById(Long loadBalancerId) {
|
|
return s_loadBalancerDao.findById(loadBalancerId);
|
|
}
|
|
|
|
public static NetworkRuleConfigVO findNetworkRuleById(Long ruleId) {
|
|
return s_networkRuleConfigDao.findById(ruleId);
|
|
}
|
|
|
|
public static SecurityGroup findSecurityGroupById(Long groupId) {
|
|
return s_securityGroupDao.findById(groupId);
|
|
}
|
|
|
|
public static HostPodVO findPodById(Long podId) {
|
|
return s_podDao.findById(podId);
|
|
}
|
|
|
|
public static VolumeVO findRootVolume(long vmId) {
|
|
List<VolumeVO> volumes = s_volumeDao.findByInstanceAndType(vmId, Type.ROOT);
|
|
if (volumes != null && volumes.size() == 1) {
|
|
return volumes.get(0);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static ServiceOffering findServiceOfferingById(Long serviceOfferingId) {
|
|
return s_serviceOfferingDao.findByIdIncludingRemoved(serviceOfferingId);
|
|
}
|
|
|
|
public static ServiceOfferingDetailsVO findServiceOfferingDetail(long serviceOfferingId, String key) {
|
|
return s_serviceOfferingDetailsDao.findDetail(serviceOfferingId, key);
|
|
}
|
|
|
|
public static Snapshot findSnapshotById(long snapshotId) {
|
|
return s_snapshotDao.findByIdIncludingRemoved(snapshotId);
|
|
}
|
|
|
|
public static StoragePoolVO findStoragePoolById(Long storagePoolId) {
|
|
return s_storagePoolDao.findByIdIncludingRemoved(storagePoolId);
|
|
}
|
|
|
|
public static VMTemplateVO findTemplateById(Long templateId) {
|
|
VMTemplateVO template = s_templateDao.findByIdIncludingRemoved(templateId);
|
|
if (template != null) {
|
|
Map<String, String> details = s_templateDetailsDao.listDetailsKeyPairs(templateId);
|
|
if (details != null && !details.isEmpty()) {
|
|
template.setDetails(details);
|
|
}
|
|
}
|
|
return template;
|
|
}
|
|
|
|
public static UploadVO findUploadById(Long id) {
|
|
return s_uploadDao.findById(id);
|
|
}
|
|
|
|
public static User findUserById(Long userId) {
|
|
return s_userDao.findById(userId);
|
|
}
|
|
|
|
public static UserVm findUserVmById(Long vmId) {
|
|
return s_userVmDao.findById(vmId);
|
|
}
|
|
|
|
public static VlanVO findVlanById(long vlanDbId) {
|
|
return s_vlanDao.findById(vlanDbId);
|
|
}
|
|
|
|
public static VolumeVO findVolumeById(Long volumeId) {
|
|
return s_volumeDao.findByIdIncludingRemoved(volumeId);
|
|
}
|
|
|
|
public static Site2SiteVpnGatewayVO findVpnGatewayById(Long vpnGatewayId) {
|
|
return s_site2SiteVpnGatewayDao.findById(vpnGatewayId);
|
|
}
|
|
|
|
public static Site2SiteCustomerGatewayVO findCustomerGatewayById(Long customerGatewayId) {
|
|
return s_site2SiteCustomerGatewayDao.findById(customerGatewayId);
|
|
}
|
|
|
|
public static List<UserVO> listUsersByAccount(long accountId) {
|
|
return s_userDao.listByAccount(accountId);
|
|
}
|
|
|
|
public static DataCenterVO findZoneById(Long zoneId) {
|
|
return s_zoneDao.findById(zoneId);
|
|
}
|
|
|
|
public static Long getAccountIdForVlan(long vlanDbId) {
|
|
List<AccountVlanMapVO> accountVlanMaps = s_accountVlanMapDao.listAccountVlanMapsByVlan(vlanDbId);
|
|
if (accountVlanMaps.isEmpty()) {
|
|
return null;
|
|
} else {
|
|
return accountVlanMaps.get(0).getAccountId();
|
|
}
|
|
}
|
|
|
|
public static Long getAccountIdForGuestVlan(long vlanDbId) {
|
|
List<AccountGuestVlanMapVO> accountGuestVlanMaps = s_accountGuestVlanMapDao.listAccountGuestVlanMapsByVlan(vlanDbId);
|
|
if (accountGuestVlanMaps.isEmpty()) {
|
|
return null;
|
|
} else {
|
|
return accountGuestVlanMaps.get(0).getAccountId();
|
|
}
|
|
}
|
|
|
|
public static HypervisorType getVolumeHyperType(long volumeId) {
|
|
return s_volumeDao.getHypervisorType(volumeId);
|
|
}
|
|
|
|
public static HypervisorType getHypervisorTypeFromFormat(long dcId, ImageFormat format){
|
|
HypervisorType type = s_storageMgr.getHypervisorTypeFromFormat(format);
|
|
if (format == ImageFormat.VHD) {
|
|
// Xenserver and Hyperv both support vhd format. Additionally hyperv is only supported
|
|
// in a dc/zone if there aren't any other hypervisor types present in the zone). If the
|
|
// format type is VHD check is any xenserver clusters are present. If not, we assume it
|
|
// is a hyperv zone and update the type.
|
|
List<ClusterVO> xenClusters = s_clusterDao.listByDcHyType(dcId, HypervisorType.XenServer.toString());
|
|
if (xenClusters.isEmpty()) {
|
|
type = HypervisorType.Hyperv;
|
|
}
|
|
} if (format == ImageFormat.RAW) {
|
|
// Currently, KVM only suppoorts RBD images of type RAW.
|
|
// This results in a weird collision with OVM volumes which
|
|
// can only be raw, thus making KVM RBD volumes show up as OVM
|
|
// rather than RBD. This block of code can (hopefuly) by checking to
|
|
// see if the pool is using either RBD or NFS. However, it isn't
|
|
// quite clear what to do if both storage types are used. If the image
|
|
// format is RAW, it narrows the hypervisor choice down to OVM and KVM / RBD or KVM / CLVM
|
|
// This would be better implemented at a cluster level.
|
|
List<StoragePoolVO> pools = s_storagePoolDao.listByDataCenterId(dcId);
|
|
ListIterator<StoragePoolVO> itr = pools.listIterator();
|
|
while(itr.hasNext()) {
|
|
StoragePoolVO pool = itr.next();
|
|
if(pool.getPoolType() == StoragePoolType.RBD || pool.getPoolType() == StoragePoolType.CLVM) {
|
|
// This case will note the presence of non-qcow2 primary stores, suggesting KVM without NFS. Otherwse,
|
|
// If this check is not passed, the hypervisor type will remain OVM.
|
|
type = HypervisorType.KVM;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
|
|
public static List<HostGpuGroupsVO> getGpuGroups(long hostId) {
|
|
return s_hostGpuGroupsDao.listByHostId(hostId);
|
|
}
|
|
|
|
public static List<VgpuTypesInfo> getGpuCapacites(Long zoneId, Long podId, Long clusterId) {
|
|
return s_vgpuTypesDao.listGPUCapacities(zoneId, podId, clusterId);
|
|
}
|
|
|
|
public static HashMap<String, Long> getVgpuVmsCount(Long zoneId, Long podId, Long clusterId) {
|
|
return s_vmDao.countVgpuVMs(zoneId, podId, clusterId);
|
|
}
|
|
|
|
public static List<VGPUTypesVO> getVgpus(long groupId) {
|
|
return s_vgpuTypesDao.listByGroupId(groupId);
|
|
}
|
|
|
|
public static List<UserStatisticsVO> listUserStatsBy(Long accountId) {
|
|
return s_userStatsDao.listBy(accountId);
|
|
}
|
|
|
|
public static List<UserVmVO> listUserVMsByHostId(long hostId) {
|
|
return s_userVmDao.listByHostId(hostId);
|
|
}
|
|
|
|
public static List<UserVmVO> listUserVMsByNetworkId(long networkId) {
|
|
return s_userVmDao.listByNetworkIdAndStates(networkId, VirtualMachine.State.Running,
|
|
VirtualMachine.State.Starting, VirtualMachine.State.Stopping, VirtualMachine.State.Unknown,
|
|
VirtualMachine.State.Migrating);
|
|
}
|
|
|
|
public static List<DomainRouterVO> listDomainRoutersByNetworkId(long networkId) {
|
|
return s_domainRouterDao.findByNetwork(networkId);
|
|
}
|
|
|
|
public static List<DataCenterVO> listZones() {
|
|
return s_zoneDao.listAll();
|
|
}
|
|
|
|
public static boolean volumeIsOnSharedStorage(long volumeId) {
|
|
// Check that the volume is valid
|
|
VolumeVO volume = s_volumeDao.findById(volumeId);
|
|
if (volume == null) {
|
|
throw new InvalidParameterValueException("Please specify a valid volume ID.");
|
|
}
|
|
|
|
return s_volumeMgr.volumeOnSharedStoragePool(volume);
|
|
}
|
|
|
|
public static List<NicProfile> getNics(VirtualMachine vm) {
|
|
return s_networkMgr.getNicProfiles(vm);
|
|
}
|
|
|
|
public static NetworkProfile getNetworkProfile(long networkId) {
|
|
return s_networkMgr.convertNetworkToNetworkProfile(networkId);
|
|
}
|
|
|
|
public static NetworkOfferingVO findNetworkOfferingById(long networkOfferingId) {
|
|
return s_networkOfferingDao.findByIdIncludingRemoved(networkOfferingId);
|
|
}
|
|
|
|
public static List<? extends Vlan> listVlanByNetworkId(long networkId) {
|
|
return s_vlanDao.listVlansByNetworkId(networkId);
|
|
}
|
|
|
|
public static PhysicalNetworkVO findPhysicalNetworkById(long id) {
|
|
return s_physicalNetworkDao.findById(id);
|
|
}
|
|
|
|
public static PhysicalNetworkTrafficTypeVO findPhysicalNetworkTrafficTypeById(long id) {
|
|
return s_physicalNetworkTrafficTypeDao.findById(id);
|
|
}
|
|
|
|
public static NetworkVO findNetworkById(long id) {
|
|
return s_networkDao.findByIdIncludingRemoved(id);
|
|
}
|
|
|
|
public static Map<Service, Map<Capability, String>> getNetworkCapabilities(long networkId, long zoneId) {
|
|
return s_networkModel.getNetworkCapabilities(networkId);
|
|
}
|
|
|
|
public static long getPublicNetworkIdByZone(long zoneId) {
|
|
return s_networkModel.getSystemNetworkByZoneAndTrafficType(zoneId, TrafficType.Public).getId();
|
|
}
|
|
|
|
public static Long getVlanNetworkId(long vlanId) {
|
|
VlanVO vlan = s_vlanDao.findById(vlanId);
|
|
if (vlan != null) {
|
|
return vlan.getNetworkId();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static Integer getNetworkRate(long networkOfferingId) {
|
|
return s_configMgr.getNetworkOfferingNetworkRate(networkOfferingId, null);
|
|
}
|
|
|
|
public static Account getVlanAccount(long vlanId) {
|
|
return s_configSvc.getVlanAccount(vlanId);
|
|
}
|
|
|
|
public static Domain getVlanDomain(long vlanId) {
|
|
return s_configSvc.getVlanDomain(vlanId);
|
|
}
|
|
|
|
public static boolean isSecurityGroupEnabledInZone(long zoneId) {
|
|
DataCenterVO dc = s_zoneDao.findById(zoneId);
|
|
if (dc == null) {
|
|
return false;
|
|
} else {
|
|
return dc.isSecurityGroupEnabled();
|
|
}
|
|
}
|
|
|
|
public static Long getDedicatedNetworkDomain(long networkId) {
|
|
return s_networkModel.getDedicatedNetworkDomain(networkId);
|
|
}
|
|
|
|
public static float getCpuOverprovisioningFactor() {
|
|
String opFactor = s_configDao.getValue(CapacityManager.CpuOverprovisioningFactorCK);
|
|
float cpuOverprovisioningFactor = NumbersUtil.parseFloat(opFactor, 1);
|
|
return cpuOverprovisioningFactor;
|
|
}
|
|
|
|
public static boolean isExtractionDisabled() {
|
|
String disableExtractionString = s_configDao.getValue(Config.DisableExtraction.toString());
|
|
boolean disableExtraction = (disableExtractionString == null) ? false : Boolean.parseBoolean(disableExtractionString);
|
|
return disableExtraction;
|
|
}
|
|
|
|
public static SecurityGroup getSecurityGroup(String groupName, long ownerId) {
|
|
return s_securityGroupMgr.getSecurityGroup(groupName, ownerId);
|
|
}
|
|
|
|
public static ConsoleProxyVO findConsoleProxy(long id) {
|
|
return s_consoleProxyDao.findById(id);
|
|
}
|
|
|
|
public static List<String> findFirewallSourceCidrs(long id) {
|
|
return s_firewallCidrsDao.getSourceCidrs(id);
|
|
}
|
|
|
|
public static Account getProjectOwner(long projectId) {
|
|
return s_projectMgr.getProjectOwner(projectId);
|
|
}
|
|
|
|
public static Project findProjectByProjectAccountId(long projectAccountId) {
|
|
return s_projectMgr.findByProjectAccountId(projectAccountId);
|
|
}
|
|
|
|
public static Project findProjectByProjectAccountIdIncludingRemoved(long projectAccountId) {
|
|
return s_projectMgr.findByProjectAccountIdIncludingRemoved(projectAccountId);
|
|
}
|
|
|
|
public static Project findProjectById(long projectId) {
|
|
return s_projectMgr.getProject(projectId);
|
|
}
|
|
|
|
public static long getProjectOwnwerId(long projectId) {
|
|
return s_projectMgr.getProjectOwner(projectId).getId();
|
|
}
|
|
|
|
public static Map<String, String> getAccountDetails(long accountId) {
|
|
Map<String, String> details = s_accountDetailsDao.findDetails(accountId);
|
|
return details.isEmpty() ? null : details;
|
|
}
|
|
|
|
public static Map<Service, Set<Provider>> listNetworkOfferingServices(long networkOfferingId) {
|
|
return s_networkModel.getNetworkOfferingServiceProvidersMap(networkOfferingId);
|
|
}
|
|
|
|
public static List<Service> getElementServices(Provider provider) {
|
|
return s_networkModel.getElementServices(provider);
|
|
}
|
|
|
|
public static List<? extends Provider> getProvidersForService(Service service) {
|
|
return s_networkModel.listSupportedNetworkServiceProviders(service.getName());
|
|
}
|
|
|
|
public static boolean canElementEnableIndividualServices(Provider serviceProvider) {
|
|
return s_networkModel.canElementEnableIndividualServices(serviceProvider);
|
|
}
|
|
|
|
public static Pair<Long, Boolean> getDomainNetworkDetails(long networkId) {
|
|
NetworkDomainVO map = s_networkDomainDao.getDomainNetworkMapByNetworkId(networkId);
|
|
|
|
boolean subdomainAccess = (map.isSubdomainAccess() != null) ? map.isSubdomainAccess() : s_networkModel.getAllowSubdomainAccessGlobal();
|
|
|
|
return new Pair<Long, Boolean>(map.getDomainId(), subdomainAccess);
|
|
}
|
|
|
|
public static long countFreePublicIps() {
|
|
return s_ipAddressDao.countFreePublicIPs();
|
|
}
|
|
|
|
public static long findDefaultRouterServiceOffering() {
|
|
ServiceOfferingVO serviceOffering = s_serviceOfferingDao.findByName(ServiceOffering.routerDefaultOffUniqueName);
|
|
return serviceOffering.getId();
|
|
}
|
|
|
|
public static IpAddress findIpByAssociatedVmId(long vmId) {
|
|
return s_ipAddressDao.findByAssociatedVmId(vmId);
|
|
}
|
|
|
|
public static String getHaTag() {
|
|
return s_haMgr.getHaTag();
|
|
}
|
|
|
|
public static Map<Service, Set<Provider>> listVpcOffServices(long vpcOffId) {
|
|
return s_vpcMgr.getVpcOffSvcProvidersMap(vpcOffId);
|
|
}
|
|
|
|
public static List<? extends Network> listVpcNetworks(long vpcId) {
|
|
return s_networkModel.listNetworksByVpc(vpcId);
|
|
}
|
|
|
|
public static boolean canUseForDeploy(Network network) {
|
|
return s_networkModel.canUseForDeploy(network);
|
|
}
|
|
|
|
public static VMSnapshot getVMSnapshotById(Long vmSnapshotId) {
|
|
VMSnapshot vmSnapshot = s_vmSnapshotDao.findById(vmSnapshotId);
|
|
return vmSnapshot;
|
|
}
|
|
|
|
public static String getUuid(String resourceId, ResourceObjectType resourceType) {
|
|
return s_taggedResourceService.getUuid(resourceId, resourceType);
|
|
}
|
|
|
|
public static List<? extends ResourceTag> listByResourceTypeAndId(ResourceObjectType type, long resourceId) {
|
|
return s_taggedResourceService.listByResourceTypeAndId(type, resourceId);
|
|
}
|
|
|
|
public static List<ConditionVO> getAutoScalePolicyConditions(long policyId) {
|
|
List<AutoScalePolicyConditionMapVO> vos = s_asPolicyConditionMapDao.listByAll(policyId, null);
|
|
ArrayList<ConditionVO> conditions = new ArrayList<ConditionVO>(vos.size());
|
|
for (AutoScalePolicyConditionMapVO vo : vos) {
|
|
conditions.add(s_asConditionDao.findById(vo.getConditionId()));
|
|
}
|
|
|
|
return conditions;
|
|
}
|
|
|
|
public static void getAutoScaleVmGroupPolicyIds(long vmGroupId, List<Long> scaleUpPolicyIds, List<Long> scaleDownPolicyIds) {
|
|
List<AutoScaleVmGroupPolicyMapVO> vos = s_asVmGroupPolicyMapDao.listByVmGroupId(vmGroupId);
|
|
for (AutoScaleVmGroupPolicyMapVO vo : vos) {
|
|
AutoScalePolicy autoScalePolicy = s_asPolicyDao.findById(vo.getPolicyId());
|
|
if (autoScalePolicy.getAction().equals("scaleup")) {
|
|
scaleUpPolicyIds.add(autoScalePolicy.getId());
|
|
} else {
|
|
scaleDownPolicyIds.add(autoScalePolicy.getId());
|
|
}
|
|
}
|
|
}
|
|
|
|
public static String getKeyPairName(String sshPublicKey) {
|
|
SSHKeyPairVO sshKeyPair = s_sshKeyPairDao.findByPublicKey(sshPublicKey);
|
|
//key might be removed prior to this point
|
|
if (sshKeyPair != null) {
|
|
return sshKeyPair.getName();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static UserVmDetailVO findPublicKeyByVmId(long vmId) {
|
|
return s_userVmDetailsDao.findDetail(vmId, "SSH.PublicKey");
|
|
}
|
|
|
|
public static void getAutoScaleVmGroupPolicies(long vmGroupId, List<AutoScalePolicy> scaleUpPolicies, List<AutoScalePolicy> scaleDownPolicies) {
|
|
List<AutoScaleVmGroupPolicyMapVO> vos = s_asVmGroupPolicyMapDao.listByVmGroupId(vmGroupId);
|
|
for (AutoScaleVmGroupPolicyMapVO vo : vos) {
|
|
AutoScalePolicy autoScalePolicy = s_asPolicyDao.findById(vo.getPolicyId());
|
|
if (autoScalePolicy.getAction().equals("scaleup")) {
|
|
scaleUpPolicies.add(autoScalePolicy);
|
|
} else {
|
|
scaleDownPolicies.add(autoScalePolicy);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static CounterVO getCounter(long counterId) {
|
|
return s_counterDao.findById(counterId);
|
|
}
|
|
|
|
public static ConditionVO findConditionById(long conditionId) {
|
|
return s_asConditionDao.findById(conditionId);
|
|
}
|
|
|
|
public static PhysicalNetworkServiceProviderVO findPhysicalNetworkServiceProviderById(long providerId) {
|
|
return s_physicalNetworkServiceProviderDao.findById(providerId);
|
|
}
|
|
|
|
public static FirewallRuleVO findFirewallRuleById(long ruleId) {
|
|
return s_firewallRuleDao.findById(ruleId);
|
|
}
|
|
|
|
public static StaticRouteVO findStaticRouteById(long routeId) {
|
|
return s_staticRouteDao.findById(routeId);
|
|
}
|
|
|
|
public static VpcGatewayVO findVpcGatewayById(long gatewayId) {
|
|
return s_vpcGatewayDao.findById(gatewayId);
|
|
}
|
|
|
|
public static AutoScalePolicyVO findAutoScalePolicyById(long policyId) {
|
|
return s_asPolicyDao.findById(policyId);
|
|
}
|
|
|
|
public static AutoScaleVmProfileVO findAutoScaleVmProfileById(long profileId) {
|
|
return s_asVmProfileDao.findById(profileId);
|
|
}
|
|
|
|
public static AutoScaleVmGroupVO findAutoScaleVmGroupById(long groupId) {
|
|
return s_asVmGroupDao.findById(groupId);
|
|
}
|
|
|
|
public static GuestOSCategoryVO findGuestOsCategoryById(long catId) {
|
|
return s_guestOSCategoryDao.findById(catId);
|
|
}
|
|
|
|
public static VpcVO findVpcById(long vpcId) {
|
|
return s_vpcDao.findById(vpcId);
|
|
}
|
|
|
|
public static SnapshotPolicy findSnapshotPolicyById(long policyId) {
|
|
return s_snapshotPolicyDao.findById(policyId);
|
|
}
|
|
|
|
public static VpcOffering findVpcOfferingById(long offeringId) {
|
|
return s_vpcOfferingDao.findById(offeringId);
|
|
}
|
|
|
|
public static NetworkACL findByNetworkACLId(long aclId) {
|
|
return s_networkACLDao.findById(aclId);
|
|
}
|
|
|
|
public static AsyncJob findAsyncJobById(long jobId) {
|
|
return s_asyncJobDao.findById(jobId);
|
|
}
|
|
|
|
public static String findJobInstanceUuid(AsyncJob job) {
|
|
if (job == null) {
|
|
return null;
|
|
}
|
|
String jobInstanceId = null;
|
|
ApiCommandJobType jobInstanceType = EnumUtils.fromString(ApiCommandJobType.class, job.getInstanceType(), ApiCommandJobType.None);
|
|
|
|
if (job.getInstanceId() == null) {
|
|
// when assert is hit, implement 'getInstanceId' of BaseAsyncCmd and return appropriate instance id
|
|
assert (false);
|
|
return null;
|
|
}
|
|
|
|
if (jobInstanceType == ApiCommandJobType.Volume) {
|
|
VolumeVO volume = ApiDBUtils.findVolumeById(job.getInstanceId());
|
|
if (volume != null) {
|
|
jobInstanceId = volume.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.Template || jobInstanceType == ApiCommandJobType.Iso) {
|
|
VMTemplateVO template = ApiDBUtils.findTemplateById(job.getInstanceId());
|
|
if (template != null) {
|
|
jobInstanceId = template.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.VirtualMachine || jobInstanceType == ApiCommandJobType.ConsoleProxy ||
|
|
jobInstanceType == ApiCommandJobType.SystemVm || jobInstanceType == ApiCommandJobType.DomainRouter) {
|
|
VMInstanceVO vm = ApiDBUtils.findVMInstanceById(job.getInstanceId());
|
|
if (vm != null) {
|
|
jobInstanceId = vm.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.Snapshot) {
|
|
Snapshot snapshot = ApiDBUtils.findSnapshotById(job.getInstanceId());
|
|
if (snapshot != null) {
|
|
jobInstanceId = snapshot.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.Host) {
|
|
Host host = ApiDBUtils.findHostById(job.getInstanceId());
|
|
if (host != null) {
|
|
jobInstanceId = host.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.StoragePool) {
|
|
StoragePoolVO spool = ApiDBUtils.findStoragePoolById(job.getInstanceId());
|
|
if (spool != null) {
|
|
jobInstanceId = spool.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.IpAddress) {
|
|
IPAddressVO ip = ApiDBUtils.findIpAddressById(job.getInstanceId());
|
|
if (ip != null) {
|
|
jobInstanceId = ip.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.SecurityGroup) {
|
|
SecurityGroup sg = ApiDBUtils.findSecurityGroupById(job.getInstanceId());
|
|
if (sg != null) {
|
|
jobInstanceId = sg.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.PhysicalNetwork) {
|
|
PhysicalNetworkVO pnet = ApiDBUtils.findPhysicalNetworkById(job.getInstanceId());
|
|
if (pnet != null) {
|
|
jobInstanceId = pnet.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.TrafficType) {
|
|
PhysicalNetworkTrafficTypeVO trafficType = ApiDBUtils.findPhysicalNetworkTrafficTypeById(job.getInstanceId());
|
|
if (trafficType != null) {
|
|
jobInstanceId = trafficType.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.PhysicalNetworkServiceProvider) {
|
|
PhysicalNetworkServiceProvider sp = ApiDBUtils.findPhysicalNetworkServiceProviderById(job.getInstanceId());
|
|
if (sp != null) {
|
|
jobInstanceId = sp.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.FirewallRule) {
|
|
FirewallRuleVO fw = ApiDBUtils.findFirewallRuleById(job.getInstanceId());
|
|
if (fw != null) {
|
|
jobInstanceId = fw.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.Account) {
|
|
Account acct = ApiDBUtils.findAccountById(job.getInstanceId());
|
|
if (acct != null) {
|
|
jobInstanceId = acct.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.User) {
|
|
User usr = ApiDBUtils.findUserById(job.getInstanceId());
|
|
if (usr != null) {
|
|
jobInstanceId = usr.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.StaticRoute) {
|
|
StaticRouteVO route = ApiDBUtils.findStaticRouteById(job.getInstanceId());
|
|
if (route != null) {
|
|
jobInstanceId = route.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.PrivateGateway) {
|
|
VpcGatewayVO gateway = ApiDBUtils.findVpcGatewayById(job.getInstanceId());
|
|
if (gateway != null) {
|
|
jobInstanceId = gateway.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.Counter) {
|
|
CounterVO counter = ApiDBUtils.getCounter(job.getInstanceId());
|
|
if (counter != null) {
|
|
jobInstanceId = counter.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.Condition) {
|
|
ConditionVO condition = ApiDBUtils.findConditionById(job.getInstanceId());
|
|
if (condition != null) {
|
|
jobInstanceId = condition.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.AutoScalePolicy) {
|
|
AutoScalePolicyVO policy = ApiDBUtils.findAutoScalePolicyById(job.getInstanceId());
|
|
if (policy != null) {
|
|
jobInstanceId = policy.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.AutoScaleVmProfile) {
|
|
AutoScaleVmProfileVO profile = ApiDBUtils.findAutoScaleVmProfileById(job.getInstanceId());
|
|
if (profile != null) {
|
|
jobInstanceId = profile.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.AutoScaleVmGroup) {
|
|
AutoScaleVmGroupVO group = ApiDBUtils.findAutoScaleVmGroupById(job.getInstanceId());
|
|
if (group != null) {
|
|
jobInstanceId = group.getUuid();
|
|
}
|
|
} else if (jobInstanceType == ApiCommandJobType.Network) {
|
|
NetworkVO networkVO = ApiDBUtils.findNetworkById(job.getInstanceId());
|
|
if(networkVO != null) {
|
|
jobInstanceId = networkVO.getUuid();
|
|
}
|
|
} else if (jobInstanceType != ApiCommandJobType.None) {
|
|
// TODO : when we hit here, we need to add instanceType -> UUID
|
|
// entity table mapping
|
|
assert (false);
|
|
}
|
|
return jobInstanceId;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// Newly Added Utility Methods for List API refactoring //
|
|
///////////////////////////////////////////////////////////////////////
|
|
|
|
public static DomainRouterResponse newDomainRouterResponse(DomainRouterJoinVO vr, Account caller) {
|
|
return s_domainRouterJoinDao.newDomainRouterResponse(vr, caller);
|
|
}
|
|
|
|
public static DomainRouterResponse fillRouterDetails(DomainRouterResponse vrData, DomainRouterJoinVO vr) {
|
|
return s_domainRouterJoinDao.setDomainRouterResponse(vrData, vr);
|
|
}
|
|
|
|
public static List<DomainRouterJoinVO> newDomainRouterView(VirtualRouter vr) {
|
|
return s_domainRouterJoinDao.newDomainRouterView(vr);
|
|
}
|
|
|
|
public static UserVmResponse newUserVmResponse(ResponseView view, String objectName, UserVmJoinVO userVm, EnumSet<VMDetails> details, Account caller) {
|
|
return s_userVmJoinDao.newUserVmResponse(view, objectName, userVm, details, caller);
|
|
}
|
|
|
|
public static UserVmResponse fillVmDetails(ResponseView view, UserVmResponse vmData, UserVmJoinVO vm) {
|
|
return s_userVmJoinDao.setUserVmResponse(view, vmData, vm);
|
|
}
|
|
|
|
public static List<UserVmJoinVO> newUserVmView(UserVm... userVms) {
|
|
return s_userVmJoinDao.newUserVmView(userVms);
|
|
}
|
|
|
|
public static SecurityGroupResponse newSecurityGroupResponse(SecurityGroupJoinVO vsg, Account caller) {
|
|
return s_securityGroupJoinDao.newSecurityGroupResponse(vsg, caller);
|
|
}
|
|
|
|
public static SecurityGroupResponse fillSecurityGroupDetails(SecurityGroupResponse vsgData, SecurityGroupJoinVO sg) {
|
|
return s_securityGroupJoinDao.setSecurityGroupResponse(vsgData, sg);
|
|
}
|
|
|
|
public static List<SecurityGroupJoinVO> newSecurityGroupView(SecurityGroup sg) {
|
|
return s_securityGroupJoinDao.newSecurityGroupView(sg);
|
|
}
|
|
|
|
public static List<SecurityGroupJoinVO> findSecurityGroupViewById(Long sgId) {
|
|
return s_securityGroupJoinDao.searchByIds(sgId);
|
|
}
|
|
|
|
public static ResourceTagResponse newResourceTagResponse(ResourceTagJoinVO vsg, boolean keyValueOnly) {
|
|
return s_tagJoinDao.newResourceTagResponse(vsg, keyValueOnly);
|
|
}
|
|
|
|
public static ResourceTagJoinVO newResourceTagView(ResourceTag sg) {
|
|
return s_tagJoinDao.newResourceTagView(sg);
|
|
}
|
|
|
|
public static ResourceTagJoinVO findResourceTagViewById(Long tagId) {
|
|
return s_tagJoinDao.searchById(tagId);
|
|
}
|
|
|
|
public static EventResponse newEventResponse(EventJoinVO ve) {
|
|
return s_eventJoinDao.newEventResponse(ve);
|
|
}
|
|
|
|
public static EventJoinVO newEventView(Event e) {
|
|
return s_eventJoinDao.newEventView(e);
|
|
}
|
|
|
|
public static InstanceGroupResponse newInstanceGroupResponse(InstanceGroupJoinVO ve) {
|
|
return s_vmGroupJoinDao.newInstanceGroupResponse(ve);
|
|
}
|
|
|
|
public static InstanceGroupJoinVO newInstanceGroupView(InstanceGroup e) {
|
|
return s_vmGroupJoinDao.newInstanceGroupView(e);
|
|
}
|
|
|
|
public static UserResponse newUserResponse(UserAccountJoinVO usr) {
|
|
return newUserResponse(usr, null);
|
|
}
|
|
|
|
public static UserResponse newUserResponse(UserAccountJoinVO usr, Long domainId) {
|
|
UserResponse response = s_userAccountJoinDao.newUserResponse(usr);
|
|
// Populate user account role information
|
|
if (usr.getAccountRoleId() != null) {
|
|
Role role = s_roleService.findRole( usr.getAccountRoleId());
|
|
if (role != null) {
|
|
response.setRoleId(role.getUuid());
|
|
response.setRoleType(role.getRoleType());
|
|
response.setRoleName(role.getName());
|
|
}
|
|
}
|
|
if (domainId != null && usr.getDomainId() != domainId)
|
|
response.setIsCallerChildDomain(true);
|
|
else
|
|
response.setIsCallerChildDomain(false);
|
|
return response;
|
|
}
|
|
|
|
public static UserAccountJoinVO newUserView(User usr) {
|
|
return s_userAccountJoinDao.newUserView(usr);
|
|
}
|
|
|
|
public static UserAccountJoinVO newUserView(UserAccount usr) {
|
|
return s_userAccountJoinDao.newUserView(usr);
|
|
}
|
|
|
|
public static ProjectResponse newProjectResponse(ProjectJoinVO proj) {
|
|
return s_projectJoinDao.newProjectResponse(proj);
|
|
}
|
|
|
|
public static ProjectResponse fillProjectDetails(ProjectResponse rsp, ProjectJoinVO proj) {
|
|
return s_projectJoinDao.setProjectResponse(rsp, proj);
|
|
}
|
|
|
|
public static List<ProjectJoinVO> newProjectView(Project proj) {
|
|
return s_projectJoinDao.newProjectView(proj);
|
|
}
|
|
|
|
public static List<UserAccountJoinVO> findUserViewByAccountId(Long accountId) {
|
|
return s_userAccountJoinDao.searchByAccountId(accountId);
|
|
}
|
|
|
|
|
|
public static ProjectAccountResponse newProjectAccountResponse(ProjectAccountJoinVO proj) {
|
|
return s_projectAccountJoinDao.newProjectAccountResponse(proj);
|
|
}
|
|
|
|
public static ProjectAccountJoinVO newProjectAccountView(ProjectAccount proj) {
|
|
return s_projectAccountJoinDao.newProjectAccountView(proj);
|
|
}
|
|
|
|
public static ProjectInvitationResponse newProjectInvitationResponse(ProjectInvitationJoinVO proj) {
|
|
return s_projectInvitationJoinDao.newProjectInvitationResponse(proj);
|
|
}
|
|
|
|
public static ProjectInvitationJoinVO newProjectInvitationView(ProjectInvitation proj) {
|
|
return s_projectInvitationJoinDao.newProjectInvitationView(proj);
|
|
}
|
|
|
|
public static HostResponse newHostResponse(HostJoinVO vr, EnumSet<HostDetails> details) {
|
|
return s_hostJoinDao.newHostResponse(vr, details);
|
|
}
|
|
|
|
public static HostResponse fillHostDetails(HostResponse vrData, HostJoinVO vr) {
|
|
return s_hostJoinDao.setHostResponse(vrData, vr);
|
|
}
|
|
|
|
public static HostForMigrationResponse newHostForMigrationResponse(HostJoinVO vr, EnumSet<HostDetails> details) {
|
|
return s_hostJoinDao.newHostForMigrationResponse(vr, details);
|
|
}
|
|
|
|
public static HostForMigrationResponse fillHostForMigrationDetails(HostForMigrationResponse vrData, HostJoinVO vr) {
|
|
return s_hostJoinDao.setHostForMigrationResponse(vrData, vr);
|
|
}
|
|
|
|
public static List<HostJoinVO> newHostView(Host vr) {
|
|
return s_hostJoinDao.newHostView(vr);
|
|
}
|
|
|
|
public static VolumeResponse newVolumeResponse(ResponseView view, VolumeJoinVO vr) {
|
|
return s_volJoinDao.newVolumeResponse(view, vr);
|
|
}
|
|
|
|
public static VolumeResponse fillVolumeDetails(ResponseView view, VolumeResponse vrData, VolumeJoinVO vr) {
|
|
return s_volJoinDao.setVolumeResponse(view, vrData, vr);
|
|
}
|
|
|
|
public static List<VolumeJoinVO> newVolumeView(Volume vr) {
|
|
return s_volJoinDao.newVolumeView(vr);
|
|
}
|
|
|
|
public static StoragePoolResponse newStoragePoolResponse(StoragePoolJoinVO vr) {
|
|
return s_poolJoinDao.newStoragePoolResponse(vr);
|
|
}
|
|
|
|
public static StorageTagResponse newStorageTagResponse(StorageTagVO vr) {
|
|
return s_tagDao.newStorageTagResponse(vr);
|
|
}
|
|
|
|
public static HostTagResponse newHostTagResponse(HostTagVO vr) {
|
|
return s_hostTagDao.newHostTagResponse(vr);
|
|
}
|
|
|
|
public static StoragePoolResponse fillStoragePoolDetails(StoragePoolResponse vrData, StoragePoolJoinVO vr) {
|
|
return s_poolJoinDao.setStoragePoolResponse(vrData, vr);
|
|
}
|
|
|
|
public static StoragePoolResponse newStoragePoolForMigrationResponse(StoragePoolJoinVO vr) {
|
|
return s_poolJoinDao.newStoragePoolForMigrationResponse(vr);
|
|
}
|
|
|
|
public static StoragePoolResponse fillStoragePoolForMigrationDetails(StoragePoolResponse vrData, StoragePoolJoinVO vr) {
|
|
return s_poolJoinDao.setStoragePoolForMigrationResponse(vrData, vr);
|
|
}
|
|
|
|
public static List<StoragePoolJoinVO> newStoragePoolView(StoragePool vr) {
|
|
return s_poolJoinDao.newStoragePoolView(vr);
|
|
}
|
|
|
|
public static ImageStoreResponse newImageStoreResponse(ImageStoreJoinVO vr) {
|
|
return s_imageStoreJoinDao.newImageStoreResponse(vr);
|
|
}
|
|
|
|
public static ImageStoreResponse fillImageStoreDetails(ImageStoreResponse vrData, ImageStoreJoinVO vr) {
|
|
return s_imageStoreJoinDao.setImageStoreResponse(vrData, vr);
|
|
}
|
|
|
|
public static List<ImageStoreJoinVO> newImageStoreView(ImageStore vr) {
|
|
return s_imageStoreJoinDao.newImageStoreView(vr);
|
|
}
|
|
|
|
public static DomainResponse newDomainResponse(ResponseView view, DomainJoinVO ve) {
|
|
return s_domainJoinDao.newDomainResponse(view, ve);
|
|
}
|
|
|
|
public static AccountResponse newAccountResponse(ResponseView view, AccountJoinVO ve) {
|
|
AccountResponse response = s_accountJoinDao.newAccountResponse(view, ve);
|
|
// Populate account role information
|
|
if (ve.getRoleId() != null) {
|
|
Role role = s_roleService.findRole(ve.getRoleId());
|
|
if (role != null) {
|
|
response.setRoleId(role.getUuid());
|
|
response.setRoleType(role.getRoleType());
|
|
response.setRoleName(role.getName());
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
|
|
public static AccountJoinVO newAccountView(Account e) {
|
|
return s_accountJoinDao.newAccountView(e);
|
|
}
|
|
|
|
public static AccountJoinVO findAccountViewById(Long accountId) {
|
|
return s_accountJoinDao.findByIdIncludingRemoved(accountId);
|
|
}
|
|
|
|
public static AsyncJobResponse newAsyncJobResponse(AsyncJobJoinVO ve) {
|
|
return s_jobJoinDao.newAsyncJobResponse(ve);
|
|
}
|
|
|
|
public static AsyncJobJoinVO newAsyncJobView(AsyncJob e) {
|
|
return s_jobJoinDao.newAsyncJobView(e);
|
|
}
|
|
|
|
public static DiskOfferingResponse newDiskOfferingResponse(DiskOfferingJoinVO offering) {
|
|
return s_diskOfferingJoinDao.newDiskOfferingResponse(offering);
|
|
}
|
|
|
|
public static DiskOfferingJoinVO newDiskOfferingView(DiskOffering offering) {
|
|
return s_diskOfferingJoinDao.newDiskOfferingView(offering);
|
|
}
|
|
|
|
public static ServiceOfferingResponse newServiceOfferingResponse(ServiceOfferingJoinVO offering) {
|
|
return s_serviceOfferingJoinDao.newServiceOfferingResponse(offering);
|
|
}
|
|
|
|
public static ServiceOfferingJoinVO newServiceOfferingView(ServiceOffering offering) {
|
|
return s_serviceOfferingJoinDao.newServiceOfferingView(offering);
|
|
}
|
|
|
|
public static ZoneResponse newDataCenterResponse(ResponseView view, DataCenterJoinVO dc, Boolean showCapacities) {
|
|
return s_dcJoinDao.newDataCenterResponse(view, dc, showCapacities);
|
|
}
|
|
|
|
public static DataCenterJoinVO newDataCenterView(DataCenter dc) {
|
|
return s_dcJoinDao.newDataCenterView(dc);
|
|
}
|
|
|
|
public static Map<String, String> findHostDetailsById(long hostId) {
|
|
return s_hostDetailsDao.findDetails(hostId);
|
|
}
|
|
|
|
public static List<NicSecondaryIpVO> findNicSecondaryIps(long nicId) {
|
|
return s_nicSecondaryIpDao.listByNicId(nicId);
|
|
}
|
|
|
|
public static TemplateResponse newTemplateUpdateResponse(TemplateJoinVO vr) {
|
|
return s_templateJoinDao.newUpdateResponse(vr);
|
|
}
|
|
|
|
public static TemplateResponse newTemplateResponse(ResponseView view, TemplateJoinVO vr) {
|
|
return s_templateJoinDao.newTemplateResponse(view, vr);
|
|
}
|
|
|
|
public static TemplateResponse newIsoResponse(TemplateJoinVO vr) {
|
|
return s_templateJoinDao.newIsoResponse(vr);
|
|
}
|
|
|
|
public static TemplateResponse fillTemplateDetails(ResponseView view, TemplateResponse vrData, TemplateJoinVO vr) {
|
|
return s_templateJoinDao.setTemplateResponse(view, vrData, vr);
|
|
}
|
|
|
|
public static List<TemplateJoinVO> newTemplateView(VirtualMachineTemplate vr) {
|
|
return s_templateJoinDao.newTemplateView(vr);
|
|
}
|
|
|
|
public static List<TemplateJoinVO> newTemplateView(VirtualMachineTemplate vr, long zoneId, boolean readyOnly) {
|
|
return s_templateJoinDao.newTemplateView(vr, zoneId, readyOnly);
|
|
}
|
|
|
|
public static AffinityGroup getAffinityGroup(String groupName, long accountId) {
|
|
return s_affinityGroupDao.findByAccountAndName(accountId, groupName);
|
|
}
|
|
|
|
public static AffinityGroupResponse newAffinityGroupResponse(AffinityGroupJoinVO group) {
|
|
return s_affinityGroupJoinDao.newAffinityGroupResponse(group);
|
|
}
|
|
|
|
public static AffinityGroupResponse fillAffinityGroupDetails(AffinityGroupResponse resp, AffinityGroupJoinVO group) {
|
|
return s_affinityGroupJoinDao.setAffinityGroupResponse(resp, group);
|
|
}
|
|
|
|
|
|
public static List<? extends LoadBalancer> listSiteLoadBalancers(long gslbRuleId) {
|
|
return s_gslbService.listSiteLoadBalancers(gslbRuleId);
|
|
}
|
|
|
|
public static String getDnsNameConfiguredForGslb() {
|
|
String providerDnsName = s_configDao.getValue(Config.CloudDnsName.key());
|
|
return providerDnsName;
|
|
}
|
|
|
|
public static Map<String, String> getResourceDetails(long resourceId, ResourceObjectType resourceType) {
|
|
Map<String, String> details = null;
|
|
if (isAdmin(CallContext.current().getCallingAccount())) {
|
|
details = s_resourceDetailsService.getDetailsMap(resourceId, resourceType, null);
|
|
} else {
|
|
details = s_resourceDetailsService.getDetailsMap(resourceId, resourceType, true);
|
|
}
|
|
return details.isEmpty() ? null : details;
|
|
}
|
|
|
|
public static boolean isAdmin(Account account) {
|
|
return s_accountService.isAdmin(account.getId());
|
|
}
|
|
|
|
public static List<ResourceTagJoinVO> listResourceTagViewByResourceUUID(String resourceUUID, ResourceObjectType resourceType) {
|
|
return s_tagJoinDao.listBy(resourceUUID, resourceType);
|
|
}
|
|
}
|