// 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 _ms;

    static AsyncJobManager _asyncMgr;

    static SecurityGroupManager _securityGroupMgr;

    static StorageManager _storageMgr;

    static VolumeOrchestrationService _volumeMgr;

    static UserVmManager _userVmMgr;

    static NetworkModel _networkModel;

    static NetworkOrchestrationService _networkMgr;

    static TemplateManager _templateMgr;

    static ConfigurationManager _configMgr;

    static StatsCollector _statsCollector;

    static AccountDao _accountDao;

    static AccountVlanMapDao _accountVlanMapDao;

    static ClusterDao _clusterDao;

    static CapacityDao _capacityDao;

    static DiskOfferingDao _diskOfferingDao;

    static DiskOfferingJoinDao _diskOfferingJoinDao;

    static DataCenterJoinDao _dcJoinDao;

    static DomainDao _domainDao;

    static DomainRouterDao _domainRouterDao;

    static DomainRouterJoinDao _domainRouterJoinDao;

    static GuestOSDao _guestOSDao;

    static GuestOSCategoryDao _guestOSCategoryDao;

    static HostDao _hostDao;

    static AccountGuestVlanMapDao _accountGuestVlanMapDao;

    static IPAddressDao _ipAddressDao;

    static LoadBalancerDao _loadBalancerDao;

    static SecurityGroupDao _securityGroupDao;

    static SecurityGroupJoinDao _securityGroupJoinDao;

    static ServiceOfferingJoinDao _serviceOfferingJoinDao;

    static NetworkRuleConfigDao _networkRuleConfigDao;

    static HostPodDao _podDao;

    static ServiceOfferingDao _serviceOfferingDao;

    static SnapshotDao _snapshotDao;

    static PrimaryDataStoreDao _storagePoolDao;

    static VMTemplateDao _templateDao;

    static VMTemplateDetailsDao _templateDetailsDao;

    static UploadDao _uploadDao;

    static UserDao _userDao;

    static UserStatisticsDao _userStatsDao;

    static UserVmDao _userVmDao;

    static UserVmJoinDao _userVmJoinDao;

    static VlanDao _vlanDao;

    static VolumeDao _volumeDao;

    static Site2SiteVpnGatewayDao _site2SiteVpnGatewayDao;

    static Site2SiteCustomerGatewayDao _site2SiteCustomerGatewayDao;

    static DataCenterDao _zoneDao;

    static NetworkOfferingDao _networkOfferingDao;

    static NetworkDao _networkDao;

    static PhysicalNetworkDao _physicalNetworkDao;

    static ConfigurationService _configSvc;

    static ConfigurationDao _configDao;

    static ConsoleProxyDao _consoleProxyDao;

    static FirewallRulesCidrsDao _firewallCidrsDao;

    static VMInstanceDao _vmDao;

    static ResourceLimitService _resourceLimitMgr;

    static ProjectService _projectMgr;

    static ResourceManager _resourceMgr;

    static AccountDetailsDao _accountDetailsDao;

    static NetworkDomainDao _networkDomainDao;

    static HighAvailabilityManager _haMgr;

    static VpcManager _vpcMgr;

    static TaggedResourceService _taggedResourceService;

    static UserVmDetailsDao _userVmDetailsDao;

    static SSHKeyPairDao _sshKeyPairDao;

    static ConditionDao _asConditionDao;

    static AutoScalePolicyConditionMapDao _asPolicyConditionMapDao;

    static AutoScaleVmGroupPolicyMapDao _asVmGroupPolicyMapDao;

    static AutoScalePolicyDao _asPolicyDao;

    static AutoScaleVmProfileDao _asVmProfileDao;

    static AutoScaleVmGroupDao _asVmGroupDao;

    static CounterDao _counterDao;

    static ResourceTagJoinDao _tagJoinDao;

    static EventJoinDao _eventJoinDao;

    static InstanceGroupJoinDao _vmGroupJoinDao;

    static UserAccountJoinDao _userAccountJoinDao;

    static ProjectJoinDao _projectJoinDao;

    static ProjectAccountJoinDao _projectAccountJoinDao;

    static ProjectInvitationJoinDao _projectInvitationJoinDao;

    static HostJoinDao _hostJoinDao;

    static VolumeJoinDao _volJoinDao;

    static StoragePoolJoinDao _poolJoinDao;

    static ImageStoreJoinDao _imageStoreJoinDao;

    static AccountJoinDao _accountJoinDao;

    static AsyncJobJoinDao _jobJoinDao;

    static TemplateJoinDao _templateJoinDao;

    static PhysicalNetworkTrafficTypeDao _physicalNetworkTrafficTypeDao;

    static PhysicalNetworkServiceProviderDao _physicalNetworkServiceProviderDao;

    static FirewallRulesDao _firewallRuleDao;

    static StaticRouteDao _staticRouteDao;

    static VpcGatewayDao _vpcGatewayDao;

    static VpcDao _vpcDao;

    static VpcOfferingDao _vpcOfferingDao;

    static SnapshotPolicyDao _snapshotPolicyDao;

    static AsyncJobDao _asyncJobDao;

    static HostDetailsDao _hostDetailsDao;

    static VMSnapshotDao _vmSnapshotDao;

    static ClusterDetailsDao _clusterDetailsDao;

    static NicSecondaryIpDao _nicSecondaryIpDao;

    static VpcProvisioningService _vpcProvSvc;

    static AffinityGroupDao _affinityGroupDao;

    static AffinityGroupJoinDao _affinityGroupJoinDao;

    static GlobalLoadBalancingRulesService _gslbService;

    static NetworkACLDao _networkACLDao;

    static AccountService _accountService;

    static ResourceMetaDataService _resourceDetailsService;

    @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 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 ApplicationLoadBalancerRuleDao _appLbDao;

    @Inject private AffinityGroupDao affinityGroupDao;

    @Inject private AffinityGroupJoinDao affinityGroupJoinDao;

    @Inject private GlobalLoadBalancingRulesService gslbService;

    @Inject private NetworkACLDao networkACLDao;

    @Inject private ServiceOfferingDetailsDao serviceOfferingDetailsDao;

    @Inject private AccountService accountService;

    @Inject private ConfigurationManager configMgr;

    @Inject private DataCenterDetailsDao zoneDetailsDao;

    @Inject private  ResourceMetaDataService resourceDetailsService;

    @PostConstruct

    void init() {

        _ms = ms;

        _configMgr = configMgr;

        _asyncMgr = asyncMgr;

        _securityGroupMgr = securityGroupMgr;

        _storageMgr = storageMgr;

        _userVmMgr = userVmMgr;

        _networkModel = networkModel;

        _networkMgr = networkMgr;

        _configSvc = configSvc;

        _templateMgr = templateMgr;

        _accountDao = accountDao;

        _accountGuestVlanMapDao = accountGuestVlanMapDao;

        _accountVlanMapDao = accountVlanMapDao;

        _clusterDao = clusterDao;

        _capacityDao = capacityDao;

        _dcJoinDao = dcJoinDao;

        _diskOfferingDao = diskOfferingDao;

        _diskOfferingJoinDao = diskOfferingJoinDao;

        _domainDao = domainDao;

        _domainRouterDao = domainRouterDao;

        _domainRouterJoinDao = domainRouterJoinDao;

        _guestOSDao = guestOSDao;

        _guestOSCategoryDao = guestOSCategoryDao;

        _hostDao = hostDao;

        _ipAddressDao = ipAddressDao;

        _loadBalancerDao = loadBalancerDao;

        _networkRuleConfigDao = networkRuleConfigDao;

        _podDao = podDao;

        _serviceOfferingDao = serviceOfferingDao;

        _serviceOfferingJoinDao = serviceOfferingJoinDao;

        _snapshotDao = snapshotDao;

        _storagePoolDao = storagePoolDao;

        _templateDao = templateDao;

        _templateDetailsDao = templateDetailsDao;

        _uploadDao = uploadDao;

        _userDao = userDao;

        _userStatsDao = userStatsDao;

        _userVmDao = userVmDao;

        _userVmJoinDao = userVmJoinDao;

        _vlanDao = vlanDao;

        _volumeDao = volumeDao;

        _site2SiteVpnGatewayDao = site2SiteVpnGatewayDao;

        _site2SiteCustomerGatewayDao = site2SiteCustomerGatewayDao;

        _zoneDao = zoneDao;

        _securityGroupDao = securityGroupDao;

        _securityGroupJoinDao = securityGroupJoinDao;

        _networkOfferingDao = networkOfferingDao;

        _networkDao = networkDao;

        _physicalNetworkDao = physicalNetworkDao;

        _configDao = configDao;

        _consoleProxyDao = consoleProxyDao;

        _firewallCidrsDao = firewallCidrsDao;

        _vmDao = vmDao;

        _resourceLimitMgr = resourceLimitMgr;

        _projectMgr = projectMgr;

        _resourceMgr = resourceMgr;

        _accountDetailsDao = accountDetailsDao;

        _networkDomainDao = networkDomainDao;

        _haMgr = haMgr;

        _vpcMgr = vpcMgr;

        _taggedResourceService = taggedResourceService;

        _sshKeyPairDao = sshKeyPairDao;

        _userVmDetailsDao = userVmDetailsDao;

        _asConditionDao = asConditionDao;

        _asPolicyDao = asPolicyDao;

        _asPolicyConditionMapDao = asPolicyConditionMapDao;

        _counterDao = counterDao;

        _asVmGroupPolicyMapDao = asVmGroupPolicyMapDao;

        _tagJoinDao = tagJoinDao;

        _vmGroupJoinDao = vmGroupJoinDao;

        _eventJoinDao = eventJoinDao;

        _userAccountJoinDao = userAccountJoinDao;

        _projectJoinDao = projectJoinDao;

        _projectAccountJoinDao = projectAccountJoinDao;

        _projectInvitationJoinDao = projectInvitationJoinDao;

        _hostJoinDao = hostJoinDao;

        _volJoinDao = volJoinDao;

        _poolJoinDao = poolJoinDao;

        _imageStoreJoinDao = imageStoreJoinDao;

        _accountJoinDao = accountJoinDao;

        _jobJoinDao = jobJoinDao;

        _templateJoinDao = templateJoinDao;

        _physicalNetworkTrafficTypeDao = physicalNetworkTrafficTypeDao;

        _physicalNetworkServiceProviderDao = physicalNetworkServiceProviderDao;

        _firewallRuleDao = firewallRuleDao;

        _staticRouteDao = staticRouteDao;

        _vpcGatewayDao = vpcGatewayDao;

        _asVmProfileDao = asVmProfileDao;

        _asVmGroupDao = asVmGroupDao;

        _vpcDao = vpcDao;

        _vpcOfferingDao = vpcOfferingDao;

        _snapshotPolicyDao = snapshotPolicyDao;

        _asyncJobDao = asyncJobDao;

        _hostDetailsDao = hostDetailsDao;

        _clusterDetailsDao = clusterDetailsDao;

        _vmSnapshotDao = vmSnapshotDao;

        _nicSecondaryIpDao = nicSecondaryIpDao;

        _vpcProvSvc = vpcProvSvc;

        _affinityGroupDao = affinityGroupDao;

        _affinityGroupJoinDao = affinityGroupJoinDao;

        _gslbService = gslbService;

        // Note: stats collector should already have been initialized by this time, otherwise a null instance is returned

        _statsCollector = StatsCollector.getInstance();

        _networkACLDao = networkACLDao;

        _accountService = accountService;

        _resourceDetailsService = resourceDetailsService;

    }

    // ///////////////////////////////////////////////////////////

    // ManagementServer methods //

    // ///////////////////////////////////////////////////////////

    public static VMInstanceVO findVMInstanceById(long vmId) {

        return _vmDao.findById(vmId);

    }

    public static long getMemoryOrCpuCapacitybyHost(Long hostId, 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 _ms.getMemoryOrCpuCapacityByHost(hostId,capacityType);

    }

    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 _ms.getMemoryOrCpuCapacityByHost(poolId, capacityType);

    }

    public static List<SummedCapacity> getCapacityByClusterPodZone(Long zoneId, Long podId, Long clusterId){

        return _capacityDao.findByClusterPodZone(zoneId,podId,clusterId);

    }

    public static List<SummedCapacity> findNonSharedStorageForClusterPodZone(Long zoneId, Long podId, Long clusterId){

        return _capacityDao.findNonSharedStorageForClusterPodZone(zoneId,podId,clusterId);

    }

    public static List<CapacityVO> getCapacityByPod(){

        return null;

    }

    public static Long getPodIdForVlan(long vlanDbId) {

        return _networkModel.getPodIdForVlan(vlanDbId);

    }

    public static String getVersion() {

        return _ms.getVersion();

    }

    public static List<UserVmJoinVO> searchForUserVMs(Criteria c, List<Long> permittedAccounts) {

        return _userVmMgr.searchForUserVMs(c, _accountDao.findById(Account.ACCOUNT_ID_SYSTEM),

                null, false, permittedAccounts, false, null, null).first();

    }

    public static List<? extends StoragePoolVO> searchForStoragePools(Criteria c) {

        return _ms.searchForStoragePools(c).first();

    }

    // ///////////////////////////////////////////////////////////

    // Manager methods //

    // ///////////////////////////////////////////////////////////

    public static long findCorrectResourceLimit(ResourceType type, long accountId) {

        AccountVO account = _accountDao.findById(accountId);

        if (account == null) {

            return -1;

        }

        return _resourceLimitMgr.findCorrectResourceLimitForAccount(account, type);

    }

    public static long findCorrectResourceLimit(Long limit, short accountType, ResourceType type) {

        return _resourceLimitMgr.findCorrectResourceLimitForAccount(accountType, limit, type);

    }

    public static long getResourceCount(ResourceType type, long accountId) {

        AccountVO account = _accountDao.findById(accountId);

        if (account == null) {

            return -1;

        }

        return _resourceLimitMgr.getResourceCount(account, type);

    }

    public static String getSecurityGroupsNamesForVm(long vmId) {

        return _securityGroupMgr.getSecurityGroupsNamesForVm(vmId);

    }

    public static List<SecurityGroupVO> getSecurityGroupsForVm(long vmId) {

        return _securityGroupMgr.getSecurityGroupsForVm(vmId);

    }

    public static String getSnapshotIntervalTypes(long snapshotId) {

        SnapshotVO snapshot = _snapshotDao.findById(snapshotId);

        return snapshot.getRecurringType().name();

    }

    public static String getStoragePoolTags(long poolId) {

        return _storageMgr.getStoragePoolTags(poolId);

    }

    public static boolean isLocalStorageActiveOnHost(Long hostId) {

        return _storageMgr.isLocalStorageActiveOnHost(hostId);

    }

    public static InstanceGroupVO findInstanceGroupForVM(long vmId) {

        return _userVmMgr.getGroupForVm(vmId);

    }

    // ///////////////////////////////////////////////////////////

    // Misc methods //

    // ///////////////////////////////////////////////////////////

    public static HostStats getHostStatistics(long hostId) {

        return _statsCollector.getHostStats(hostId);

    }

    public static StorageStats getStoragePoolStatistics(long id) {

        return _statsCollector.getStoragePoolStats(id);

    }

    public static VmStats getVmStatistics(long hostId) {

        return _statsCollector.getVmStats(hostId);

    }

    public static StorageStats getSecondaryStorageStatistics(long id) {

        return _statsCollector.getStorageStats(id);

    }

    public static CapacityVO getStoragePoolUsedStats(Long poolId, Long clusterId, Long podId, Long zoneId){

        return _storageMgr.getStoragePoolUsedStats(poolId, clusterId, podId, zoneId);

    }

    public static CapacityVO getSecondaryStorageUsedStats(Long hostId, Long zoneId){

        return _storageMgr.getSecondaryStorageUsedStats(hostId, zoneId);

    }

    // ///////////////////////////////////////////////////////////

    // Dao methods //

    // ///////////////////////////////////////////////////////////

    public static Account findAccountById(Long accountId) {

        return _accountDao.findByIdIncludingRemoved(accountId);

    }

    public static Account findAccountByIdIncludingRemoved(Long accountId) {

        return _accountDao.findByIdIncludingRemoved(accountId);

    }

    public static Account findAccountByNameDomain(String accountName, Long domainId) {

        return _accountDao.findActiveAccount(accountName, domainId);

    }

    public static ClusterVO findClusterById(long clusterId) {

        return _clusterDao.findById(clusterId);

    }

    public static String findClusterDetails(long clusterId, String name){

        ClusterDetailsVO detailsVO = _clusterDetailsDao.findDetail(clusterId,name);

        if (detailsVO != null) {

            return detailsVO.getValue();

        }

        return null;

    }

    public static DiskOfferingVO findDiskOfferingById(Long diskOfferingId) {

        return _diskOfferingDao.findByIdIncludingRemoved(diskOfferingId);

    }

    public static DomainVO findDomainById(Long domainId) {

        return _domainDao.findByIdIncludingRemoved(domainId);

    }

    public static DomainVO findDomainByIdIncludingRemoved(Long domainId) {

        return _domainDao.findByIdIncludingRemoved(domainId);

    }

    public static boolean isChildDomain(long parentId, long childId) {

        return _domainDao.isChildDomain(parentId, childId);

    }

    public static DomainRouterVO findDomainRouterById(Long routerId) {

        return _domainRouterDao.findByIdIncludingRemoved(routerId);

    }

    public static GuestOS findGuestOSById(Long id) {

        return _guestOSDao.findByIdIncludingRemoved(id);

    }

    public static GuestOS findGuestOSByDisplayName(String displayName) {

        return _guestOSDao.listByDisplayName(displayName);

    }

    public static HostVO findHostById(Long hostId) {

        return _hostDao.findByIdIncludingRemoved(hostId);

    }

    public static IPAddressVO findIpAddressById(long addressId) {

        return _ipAddressDao.findById(addressId);

    }

    public static GuestOSCategoryVO getHostGuestOSCategory(long hostId) {

        Long guestOSCategoryID = _resourceMgr.getGuestOSCategoryId(hostId);

        if (guestOSCategoryID != null) {

            return _guestOSCategoryDao.findById(guestOSCategoryID);

        } else {

            return null;

        }

    }

    public static String getHostTags(long hostId) {

        return _resourceMgr.getHostTags(hostId);

    }

    public static LoadBalancerVO findLoadBalancerById(Long loadBalancerId) {

        return _loadBalancerDao.findById(loadBalancerId);

    }

    public static NetworkRuleConfigVO findNetworkRuleById(Long ruleId) {

        return _networkRuleConfigDao.findById(ruleId);

    }

    public static SecurityGroup findSecurityGroupById(Long groupId) {

        return _securityGroupDao.findById(groupId);

    }

    public static HostPodVO findPodById(Long podId) {

        return _podDao.findById(podId);

    }

    public static VolumeVO findRootVolume(long vmId) {

        List<VolumeVO> volumes = _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 _serviceOfferingDao.findByIdIncludingRemoved(serviceOfferingId);

    }

    public static Snapshot findSnapshotById(long snapshotId) {

        SnapshotVO snapshot = _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 _storagePoolDao.findByIdIncludingRemoved(storagePoolId);

    }

    public static VMTemplateVO findTemplateById(Long templateId) {

        VMTemplateVO template = _templateDao.findByIdIncludingRemoved(templateId);

        if(template != null) {

            Map<String, String> details = _templateDetailsDao.listDetailsKeyPairs(templateId);

            if(details != null && !details.isEmpty()) {

                template.setDetails(details);

            }

        }

        return template;

    }

    public static UploadVO findUploadById(Long id) {

        return _uploadDao.findById(id);

    }

    public static User findUserById(Long userId) {

        return _userDao.findById(userId);

    }

    public static UserVm findUserVmById(Long vmId) {

        return _userVmDao.findById(vmId);

    }

    public static VlanVO findVlanById(long vlanDbId) {

        return _vlanDao.findById(vlanDbId);

    }

    public static VolumeVO findVolumeById(Long volumeId) {

        return _volumeDao.findByIdIncludingRemoved(volumeId);

    }

    public static Site2SiteVpnGatewayVO findVpnGatewayById(Long vpnGatewayId) {

        return _site2SiteVpnGatewayDao.findById(vpnGatewayId);

    }

    public static Site2SiteCustomerGatewayVO findCustomerGatewayById(Long customerGatewayId) {

        return _site2SiteCustomerGatewayDao.findById(customerGatewayId);

    }

    public static List<UserVO> listUsersByAccount(long accountId) {

        return _userDao.listByAccount(accountId);

    }

    public static DataCenterVO findZoneById(Long zoneId) {

        return _zoneDao.findById(zoneId);

    }

    public static Long getAccountIdForVlan(long vlanDbId) {

        List<AccountVlanMapVO> accountVlanMaps = _accountVlanMapDao.listAccountVlanMapsByVlan(vlanDbId);

        if (accountVlanMaps.isEmpty()) {

            return null;

        } else {

            return accountVlanMaps.get(0).getAccountId();

        }

    }

    public static Long getAccountIdForGuestVlan(long vlanDbId) {

        List<AccountGuestVlanMapVO> accountGuestVlanMaps = _accountGuestVlanMapDao.listAccountGuestVlanMapsByVlan(vlanDbId);

        if (accountGuestVlanMaps.isEmpty()) {

            return null;

        } else {

            return accountGuestVlanMaps.get(0).getAccountId();

        }

    }

    public static HypervisorType getVolumeHyperType(long volumeId) {

        return _volumeDao.getHypervisorType(volumeId);

    }

    public static HypervisorType getHypervisorTypeFromFormat(long dcId, ImageFormat format){

        HypervisorType type = _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 = _clusterDao.listByDcHyType(dcId, HypervisorType.XenServer.toString());

            if (xenClusters.isEmpty()) {

                type = HypervisorType.Hyperv;

            }

        }

        return type;

    }

    public static List<UserStatisticsVO> listUserStatsBy(Long accountId) {

        return _userStatsDao.listBy(accountId);

    }

    public static List<UserVmVO> listUserVMsByHostId(long hostId) {

        return _userVmDao.listByHostId(hostId);

    }

    public static List<DataCenterVO> listZones() {

        return _zoneDao.listAll();

    }

    public static boolean volumeIsOnSharedStorage(long volumeId) {

        // Check that the volume is valid

        VolumeVO volume = _volumeDao.findById(volumeId);

        if (volume == null) {

            throw new InvalidParameterValueException("Please specify a valid volume ID.");

        }

        return _volumeMgr.volumeOnSharedStoragePool(volume);

    }

    public static List<NicProfile> getNics(VirtualMachine vm) {

        return _networkMgr.getNicProfiles(vm);

    }

    public static NetworkProfile getNetworkProfile(long networkId) {

        return _networkMgr.convertNetworkToNetworkProfile(networkId);

    }

    public static NetworkOfferingVO findNetworkOfferingById(long networkOfferingId) {

        return _networkOfferingDao.findByIdIncludingRemoved(networkOfferingId);

    }

    public static List<? extends Vlan> listVlanByNetworkId(long networkId) {

        return _vlanDao.listVlansByNetworkId(networkId);

    }

    public static PhysicalNetworkVO findPhysicalNetworkById(long id) {

        return _physicalNetworkDao.findById(id);

    }

    public static PhysicalNetworkTrafficTypeVO findPhysicalNetworkTrafficTypeById(long id) {

        return _physicalNetworkTrafficTypeDao.findById(id);

    }

    public static NetworkVO findNetworkById(long id) {

        return _networkDao.findById(id);

    }

    public static Map<Service, Map<Capability, String>> getNetworkCapabilities(long networkId, long zoneId) {

        return _networkModel.getNetworkCapabilities(networkId);

    }

    public static long getPublicNetworkIdByZone(long zoneId) {

        return _networkModel.getSystemNetworkByZoneAndTrafficType(zoneId, TrafficType.Public).getId();

    }

    public static Long getVlanNetworkId(long vlanId) {

        VlanVO vlan = _vlanDao.findById(vlanId);

        if (vlan != null) {

            return vlan.getNetworkId();

        } else {

            return null;

        }

    }

    public static Integer getNetworkRate(long networkOfferingId) {

        return _configMgr.getNetworkOfferingNetworkRate(networkOfferingId, null);

    }

    public static Account getVlanAccount(long vlanId) {

        return _configSvc.getVlanAccount(vlanId);

    }

    public static boolean isSecurityGroupEnabledInZone(long zoneId) {

        DataCenterVO dc = _zoneDao.findById(zoneId);

        if (dc == null) {

            return false;

        } else {

            return dc.isSecurityGroupEnabled();

        }

    }

    public static Long getDedicatedNetworkDomain(long networkId) {

        return _networkModel.getDedicatedNetworkDomain(networkId);

    }

    public static float getCpuOverprovisioningFactor() {

        String opFactor = _configDao.getValue(CapacityManager.CpuOverprovisioningFactorCK);

        float cpuOverprovisioningFactor = NumbersUtil.parseFloat(opFactor, 1);

        return cpuOverprovisioningFactor;

    }

    public static boolean isExtractionDisabled(){

        String disableExtractionString = _configDao.getValue(Config.DisableExtraction.toString());

        boolean disableExtraction  = (disableExtractionString == null) ? false : Boolean.parseBoolean(disableExtractionString);

        return disableExtraction;

    }

    public static SecurityGroup getSecurityGroup(String groupName, long ownerId) {

        return _securityGroupMgr.getSecurityGroup(groupName, ownerId);

    }

    public static ConsoleProxyVO findConsoleProxy(long id) {

        return _consoleProxyDao.findById(id);

    }

    public static List<String> findFirewallSourceCidrs(long id){

        return _firewallCidrsDao.getSourceCidrs(id);

    }

    public static Account getProjectOwner(long projectId) {

        return _projectMgr.getProjectOwner(projectId);

    }

    public static Project findProjectByProjectAccountId(long projectAccountId) {

        return _projectMgr.findByProjectAccountId(projectAccountId);

    }

    public static Project findProjectByProjectAccountIdIncludingRemoved(long projectAccountId) {

        return _projectMgr.findByProjectAccountIdIncludingRemoved(projectAccountId);

    }

    public static Project findProjectById(long projectId) {

        return _projectMgr.getProject(projectId);

    }

    public static long getProjectOwnwerId(long projectId) {

        return _projectMgr.getProjectOwner(projectId).getId();

    }

    public static Map<String, String> getAccountDetails(long accountId) {

        Map<String, String> details = _accountDetailsDao.findDetails(accountId);

        return details.isEmpty() ? null : details;

    }

    public static Map<Service, Set<Provider>> listNetworkOfferingServices(long networkOfferingId) {

        return _networkModel.getNetworkOfferingServiceProvidersMap(networkOfferingId);

    }

    public static List<Service> getElementServices(Provider provider) {

        return _networkModel.getElementServices(provider);

    }

    public static List<? extends Provider> getProvidersForService(Service service) {

        return _networkModel.listSupportedNetworkServiceProviders(service.getName());

    }

    public static boolean canElementEnableIndividualServices(Provider serviceProvider) {

        return _networkModel.canElementEnableIndividualServices(serviceProvider);

    }

    public static Pair<Long, Boolean> getDomainNetworkDetails(long networkId) {

        NetworkDomainVO map = _networkDomainDao.getDomainNetworkMapByNetworkId(networkId);

        boolean subdomainAccess = (map.isSubdomainAccess() != null) ? map.isSubdomainAccess() : _networkModel.getAllowSubdomainAccessGlobal();

        return new Pair<Long, Boolean>(map.getDomainId(), subdomainAccess);

    }

    public static long countFreePublicIps() {

        return _ipAddressDao.countFreePublicIPs();

    }

    public static long findDefaultRouterServiceOffering() {

        ServiceOfferingVO serviceOffering = _serviceOfferingDao.findByName(ServiceOffering.routerDefaultOffUniqueName);

        return serviceOffering.getId();

    }

    public static IpAddress findIpByAssociatedVmId(long vmId) {

        return _ipAddressDao.findByAssociatedVmId(vmId);

    }

    public static String getHaTag() {

        return _haMgr.getHaTag();

    }

    public static Map<Service, Set<Provider>> listVpcOffServices(long vpcOffId) {

        return _vpcMgr.getVpcOffSvcProvidersMap(vpcOffId);

    }

    public static List<? extends Network> listVpcNetworks(long vpcId) {

        return _networkModel.listNetworksByVpc(vpcId);

    }

    public static boolean canUseForDeploy(Network network) {

        return _networkModel.canUseForDeploy(network);

    }

    public static VMSnapshot getVMSnapshotById(Long vmSnapshotId) {

        VMSnapshot vmSnapshot = _vmSnapshotDao.findById(vmSnapshotId);

        return vmSnapshot;

    }

    public static String getUuid(String resourceId, ResourceObjectType resourceType) {

        return _taggedResourceService.getUuid(resourceId, resourceType);

    }

    public static List<? extends ResourceTag> listByResourceTypeAndId(ResourceObjectType type, long resourceId) {

        return _taggedResourceService.listByResourceTypeAndId(type, resourceId);

    }

    public static List<ConditionVO> getAutoScalePolicyConditions(long policyId)

    {

        List<AutoScalePolicyConditionMapVO> vos = _asPolicyConditionMapDao.listByAll(policyId, null);

        ArrayList<ConditionVO> conditions = new ArrayList<ConditionVO>(vos.size());

        for (AutoScalePolicyConditionMapVO vo : vos) {

            conditions.add(_asConditionDao.findById(vo.getConditionId()));

        }

        return conditions;

    }

    public static void getAutoScaleVmGroupPolicyIds(long vmGroupId, List<Long> scaleUpPolicyIds, List<Long> scaleDownPolicyIds)

    {

        List<AutoScaleVmGroupPolicyMapVO> vos = _asVmGroupPolicyMapDao.listByVmGroupId(vmGroupId);

        for (AutoScaleVmGroupPolicyMapVO vo : vos) {

            AutoScalePolicy autoScalePolicy = _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 = _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 _userVmDetailsDao.findDetail(vmId, "SSH.PublicKey");

    }

    public static void getAutoScaleVmGroupPolicies(long vmGroupId, List<AutoScalePolicy> scaleUpPolicies, List<AutoScalePolicy> scaleDownPolicies)

    {

        List<AutoScaleVmGroupPolicyMapVO> vos = _asVmGroupPolicyMapDao.listByVmGroupId(vmGroupId);

        for (AutoScaleVmGroupPolicyMapVO vo : vos) {

            AutoScalePolicy autoScalePolicy = _asPolicyDao.findById(vo.getPolicyId());

            if(autoScalePolicy.getAction().equals("scaleup")) {

                scaleUpPolicies.add(autoScalePolicy);

            } else {

                scaleDownPolicies.add(autoScalePolicy);

            }

        }

    }

    public static CounterVO getCounter(long counterId) {

        return _counterDao.findById(counterId);

    }

    public static ConditionVO findConditionById(long conditionId){

        return _asConditionDao.findById(conditionId);

    }

    public static PhysicalNetworkServiceProviderVO findPhysicalNetworkServiceProviderById(long providerId){

        return _physicalNetworkServiceProviderDao.findById(providerId);

    }

    public static FirewallRuleVO findFirewallRuleById(long ruleId){

        return _firewallRuleDao.findById(ruleId);

    }

    public static StaticRouteVO findStaticRouteById(long routeId){

        return _staticRouteDao.findById(routeId);

    }

    public static VpcGatewayVO findVpcGatewayById(long gatewayId){

        return _vpcGatewayDao.findById(gatewayId);

    }

    public static AutoScalePolicyVO findAutoScalePolicyById(long policyId){

        return _asPolicyDao.findById(policyId);

    }

    public static AutoScaleVmProfileVO findAutoScaleVmProfileById(long profileId){

        return _asVmProfileDao.findById(profileId);

    }

    public static AutoScaleVmGroupVO findAutoScaleVmGroupById(long groupId){

        return _asVmGroupDao.findById(groupId);

    }

    public static GuestOSCategoryVO findGuestOsCategoryById(long catId){

        return _guestOSCategoryDao.findById(catId);

    }

    public static VpcVO findVpcById(long vpcId){

        return _vpcDao.findById(vpcId);

    }

    public static SnapshotPolicy findSnapshotPolicyById(long policyId){

        return _snapshotPolicyDao.findById(policyId);

    }

    public static VpcOffering findVpcOfferingById(long offeringId){

        return _vpcOfferingDao.findById(offeringId);

    }

    public static NetworkACL findByNetworkACLId(long aclId){

        return _networkACLDao.findById(aclId);

    }

    public static AsyncJob findAsyncJobById(long jobId){