// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License.  You may obtain a copy of the License at

//

//   http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied.  See the License for the

// specific language governing permissions and limitations

// under the License.

    private 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 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 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_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) {

        return s_diskOfferingDao.findByIdIncludingRemoved(diskOfferingId);

    }

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