mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
1898 lines
73 KiB
Java
Executable File
1898 lines
73 KiB
Java
Executable File
// 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.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.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.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.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.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.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 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 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 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 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_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_accountService = accountService;
|
|
s_resourceDetailsService = resourceDetailsService;
|
|
s_hostGpuGroupsDao = hostGpuGroupsDao;
|
|
s_vgpuTypesDao = vgpuTypesDao;
|
|
}
|
|
|
|
// ///////////////////////////////////////////////////////////
|
|
// ManagementServer methods //
|
|
// ///////////////////////////////////////////////////////////
|
|
|
|
public static VMInstanceVO findVMInstanceById(long vmId) {
|
|
return s_vmDao.findById(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 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 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) {
|
|
SnapshotVO snapshot = s_snapshotDao.findById(snapshotId);
|
|
if (snapshot != null && snapshot.getRemoved() == null && snapshot.getState() == Snapshot.State.BackedUp) {
|
|
return snapshot;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
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.findById(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 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.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);
|
|
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 AccountResponse newAccountResponse(ResponseView view, AccountJoinVO ve) {
|
|
return s_accountJoinDao.newAccountResponse(view, ve);
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|