mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
ebdc1f069d
2) Build HostResonse object in ApiResponseHelper for add/reconnect/update/prepareForMaintenance/cancelMaintenance commands
626 lines
29 KiB
Java
626 lines
29 KiB
Java
/**
|
|
* Copyright (C) 2010 Cloud.com, Inc. All rights reserved.
|
|
*
|
|
* This software is licensed under the GNU General Public License v3 or later.
|
|
*
|
|
* It is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or any later version.
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
package com.cloud.api;
|
|
|
|
import java.text.DecimalFormat;
|
|
import java.util.Date;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
|
|
import com.cloud.api.response.AccountResponse;
|
|
import com.cloud.api.response.ConfigurationResponse;
|
|
import com.cloud.api.response.DiskOfferingResponse;
|
|
import com.cloud.api.response.DomainResponse;
|
|
import com.cloud.api.response.DomainRouterResponse;
|
|
import com.cloud.api.response.HostResponse;
|
|
import com.cloud.api.response.ResourceLimitResponse;
|
|
import com.cloud.api.response.ServiceOfferingResponse;
|
|
import com.cloud.api.response.SnapshotPolicyResponse;
|
|
import com.cloud.api.response.SnapshotResponse;
|
|
import com.cloud.api.response.SystemVmResponse;
|
|
import com.cloud.api.response.UserResponse;
|
|
import com.cloud.api.response.UserVmResponse;
|
|
import com.cloud.async.AsyncJobVO;
|
|
import com.cloud.configuration.ConfigurationVO;
|
|
import com.cloud.configuration.ResourceCount.ResourceType;
|
|
import com.cloud.configuration.ResourceLimitVO;
|
|
import com.cloud.dc.ClusterVO;
|
|
import com.cloud.domain.DomainVO;
|
|
import com.cloud.host.Host;
|
|
import com.cloud.host.HostStats;
|
|
import com.cloud.host.HostVO;
|
|
import com.cloud.host.Status.Event;
|
|
import com.cloud.offering.NetworkOffering.GuestIpType;
|
|
import com.cloud.offering.ServiceOffering;
|
|
import com.cloud.server.Criteria;
|
|
import com.cloud.service.ServiceOfferingVO;
|
|
import com.cloud.storage.DiskOfferingVO;
|
|
import com.cloud.storage.GuestOSCategoryVO;
|
|
import com.cloud.storage.Snapshot;
|
|
import com.cloud.storage.Snapshot.SnapshotType;
|
|
import com.cloud.storage.SnapshotPolicyVO;
|
|
import com.cloud.storage.StoragePoolVO;
|
|
import com.cloud.storage.VMTemplateVO;
|
|
import com.cloud.storage.VolumeVO;
|
|
import com.cloud.user.Account;
|
|
import com.cloud.user.UserAccount;
|
|
import com.cloud.user.UserContext;
|
|
import com.cloud.user.UserStatisticsVO;
|
|
import com.cloud.uservm.UserVm;
|
|
import com.cloud.vm.ConsoleProxyVO;
|
|
import com.cloud.vm.DomainRouter;
|
|
import com.cloud.vm.InstanceGroupVO;
|
|
import com.cloud.vm.SecondaryStorageVmVO;
|
|
import com.cloud.vm.State;
|
|
import com.cloud.vm.SystemVm;
|
|
import com.cloud.vm.UserVmVO;
|
|
import com.cloud.vm.VMInstanceVO;
|
|
import com.cloud.vm.VmStats;
|
|
|
|
public class ApiResponseHelper {
|
|
|
|
public static UserResponse createUserResponse (UserAccount user) {
|
|
UserResponse userResponse = new UserResponse();
|
|
userResponse.setAccountName(user.getAccountName());
|
|
userResponse.setAccountType(user.getType());
|
|
userResponse.setCreated(user.getCreated());
|
|
userResponse.setDomainId(user.getDomainId());
|
|
userResponse.setDomainName(ApiDBUtils.findDomainById(user.getDomainId()).getName());
|
|
userResponse.setEmail(user.getEmail());
|
|
userResponse.setFirstname(user.getFirstname());
|
|
userResponse.setId(user.getId());
|
|
userResponse.setLastname(user.getLastname());
|
|
userResponse.setState(user.getState());
|
|
userResponse.setTimezone(user.getTimezone());
|
|
userResponse.setUsername(user.getUsername());
|
|
userResponse.setApiKey(user.getApiKey());
|
|
userResponse.setSecretKey(user.getSecretKey());
|
|
|
|
return userResponse;
|
|
}
|
|
|
|
public static AccountResponse createAccountResponse (Account account) {
|
|
boolean accountIsAdmin = (account.getType() == Account.ACCOUNT_TYPE_ADMIN);
|
|
AccountResponse accountResponse = new AccountResponse();
|
|
accountResponse.setId(account.getId());
|
|
accountResponse.setName(account.getAccountName());
|
|
accountResponse.setAccountType(account.getType());
|
|
accountResponse.setDomainId(account.getDomainId());
|
|
accountResponse.setDomainName(ApiDBUtils.findDomainById(account.getDomainId()).getName());
|
|
|
|
//get network stat
|
|
List<UserStatisticsVO> stats = ApiDBUtils.listUserStatsBy(account.getId());
|
|
if (stats == null) {
|
|
throw new ServerApiException(BaseCmd.INTERNAL_ERROR, "Internal error searching for user stats");
|
|
}
|
|
|
|
long bytesSent = 0;
|
|
long bytesReceived = 0;
|
|
for (UserStatisticsVO stat : stats) {
|
|
long rx = stat.getNetBytesReceived() + stat.getCurrentBytesReceived();
|
|
long tx = stat.getNetBytesSent() + stat.getCurrentBytesSent();
|
|
bytesReceived = bytesReceived + Long.valueOf(rx);
|
|
bytesSent = bytesSent + Long.valueOf(tx);
|
|
}
|
|
accountResponse.setBytesReceived(bytesReceived);
|
|
accountResponse.setBytesSent(bytesSent);
|
|
|
|
// Get resource limits and counts
|
|
|
|
long vmLimit = ApiDBUtils.findCorrectResourceLimit(ResourceType.user_vm, account.getId());
|
|
String vmLimitDisplay = (accountIsAdmin || vmLimit == -1) ? "Unlimited" : String.valueOf(vmLimit);
|
|
long vmTotal = ApiDBUtils.getResourceCount(ResourceType.user_vm, account.getId());
|
|
String vmAvail = (accountIsAdmin || vmLimit == -1) ? "Unlimited" : String.valueOf(vmLimit - vmTotal);
|
|
accountResponse.setVmLimit(vmLimitDisplay);
|
|
accountResponse.setVmTotal(vmTotal);
|
|
accountResponse.setVmAvailable(vmAvail);
|
|
|
|
long ipLimit = ApiDBUtils.findCorrectResourceLimit(ResourceType.public_ip, account.getId());
|
|
String ipLimitDisplay = (accountIsAdmin || ipLimit == -1) ? "Unlimited" : String.valueOf(ipLimit);
|
|
long ipTotal = ApiDBUtils.getResourceCount(ResourceType.public_ip, account.getId());
|
|
String ipAvail = (accountIsAdmin || ipLimit == -1) ? "Unlimited" : String.valueOf(ipLimit - ipTotal);
|
|
accountResponse.setIpLimit(ipLimitDisplay);
|
|
accountResponse.setIpTotal(ipTotal);
|
|
accountResponse.setIpAvailable(ipAvail);
|
|
|
|
long volumeLimit = ApiDBUtils.findCorrectResourceLimit(ResourceType.volume, account.getId());
|
|
String volumeLimitDisplay = (accountIsAdmin || volumeLimit == -1) ? "Unlimited" : String.valueOf(volumeLimit);
|
|
long volumeTotal = ApiDBUtils.getResourceCount(ResourceType.volume, account.getId());
|
|
String volumeAvail = (accountIsAdmin || volumeLimit == -1) ? "Unlimited" : String.valueOf(volumeLimit - volumeTotal);
|
|
accountResponse.setVolumeLimit(volumeLimitDisplay);
|
|
accountResponse.setVolumeTotal(volumeTotal);
|
|
accountResponse.setVolumeAvailable(volumeAvail);
|
|
|
|
long snapshotLimit = ApiDBUtils.findCorrectResourceLimit(ResourceType.snapshot, account.getId());
|
|
String snapshotLimitDisplay = (accountIsAdmin || snapshotLimit == -1) ? "Unlimited" : String.valueOf(snapshotLimit);
|
|
long snapshotTotal = ApiDBUtils.getResourceCount(ResourceType.snapshot, account.getId());
|
|
String snapshotAvail = (accountIsAdmin || snapshotLimit == -1) ? "Unlimited" : String.valueOf(snapshotLimit - snapshotTotal);
|
|
accountResponse.setSnapshotLimit(snapshotLimitDisplay);
|
|
accountResponse.setSnapshotTotal(snapshotTotal);
|
|
accountResponse.setSnapshotAvailable(snapshotAvail);
|
|
|
|
long templateLimit = ApiDBUtils.findCorrectResourceLimit(ResourceType.template, account.getId());
|
|
String templateLimitDisplay = (accountIsAdmin || templateLimit == -1) ? "Unlimited" : String.valueOf(templateLimit);
|
|
long templateTotal = ApiDBUtils.getResourceCount(ResourceType.template, account.getId());
|
|
String templateAvail = (accountIsAdmin || templateLimit == -1) ? "Unlimited" : String.valueOf(templateLimit - templateTotal);
|
|
accountResponse.setTemplateLimit(templateLimitDisplay);
|
|
accountResponse.setTemplateTotal(templateTotal);
|
|
accountResponse.setTemplateAvailable(templateAvail);
|
|
|
|
// Get stopped and running VMs
|
|
int vmStopped = 0;
|
|
int vmRunning = 0;
|
|
|
|
Long[] accountIds = new Long[1];
|
|
accountIds[0] = account.getId();
|
|
|
|
Criteria c1 = new Criteria();
|
|
c1.addCriteria(Criteria.ACCOUNTID, accountIds);
|
|
List<? extends UserVm> virtualMachines = ApiDBUtils.searchForUserVMs(c1);
|
|
|
|
//get Running/Stopped VMs
|
|
for (Iterator<? extends UserVm> iter = virtualMachines.iterator(); iter.hasNext();) {
|
|
// count how many stopped/running vms we have
|
|
UserVm vm = iter.next();
|
|
|
|
if (vm.getState() == State.Stopped) {
|
|
vmStopped++;
|
|
} else if (vm.getState() == State.Running) {
|
|
vmRunning++;
|
|
}
|
|
}
|
|
|
|
accountResponse.setVmStopped(vmStopped);
|
|
accountResponse.setVmRunning(vmRunning);
|
|
|
|
return accountResponse;
|
|
}
|
|
|
|
public static DomainResponse createDomainResponse (DomainVO domain) {
|
|
DomainResponse domainResponse = new DomainResponse();
|
|
domainResponse.setDomainName(domain.getName());
|
|
domainResponse.setId(domain.getId());
|
|
domainResponse.setLevel(domain.getLevel());
|
|
domainResponse.setParentDomainId(domain.getParent());
|
|
if (domain.getParent() != null) {
|
|
domainResponse.setParentDomainName(ApiDBUtils.findDomainById(domain.getParent()).getName());
|
|
}
|
|
if (domain.getChildCount() > 0) {
|
|
domainResponse.setHasChild(true);
|
|
}
|
|
return domainResponse;
|
|
}
|
|
|
|
public static DiskOfferingResponse createDiskOfferingResponse (DiskOfferingVO offering) {
|
|
DiskOfferingResponse diskOfferingResponse = new DiskOfferingResponse();
|
|
diskOfferingResponse.setId(offering.getId());
|
|
diskOfferingResponse.setName(offering.getName());
|
|
diskOfferingResponse.setDisplayText(offering.getDisplayText());
|
|
diskOfferingResponse.setCreated(offering.getCreated());
|
|
diskOfferingResponse.setDiskSize(offering.getDiskSize());
|
|
if(offering.getDomainId() != null){
|
|
diskOfferingResponse.setDomain(ApiDBUtils.findDomainById(offering.getDomainId()).getName());
|
|
diskOfferingResponse.setDomainId(offering.getDomainId());
|
|
}
|
|
diskOfferingResponse.setTags(offering.getTags());
|
|
return diskOfferingResponse;
|
|
}
|
|
|
|
public static ResourceLimitResponse createResourceLimitResponse (ResourceLimitVO limit) {
|
|
ResourceLimitResponse resourceLimitResponse = new ResourceLimitResponse();
|
|
if (limit.getDomainId() != null) {
|
|
resourceLimitResponse.setDomainId(limit.getDomainId());
|
|
resourceLimitResponse.setDomainName(ApiDBUtils.findDomainById(limit.getDomainId()).getName());
|
|
}
|
|
|
|
if (limit.getAccountId() != null) {
|
|
Account accountTemp = ApiDBUtils.findAccountById(limit.getAccountId());
|
|
if (accountTemp != null) {
|
|
resourceLimitResponse.setAccountName(accountTemp.getAccountName());
|
|
resourceLimitResponse.setDomainId(accountTemp.getDomainId());
|
|
resourceLimitResponse.setDomainName(ApiDBUtils.findDomainById(accountTemp.getDomainId()).getName());
|
|
}
|
|
}
|
|
resourceLimitResponse.setResourceType(Integer.valueOf(limit.getType().ordinal()).toString());
|
|
resourceLimitResponse.setMax(limit.getMax());
|
|
|
|
return resourceLimitResponse;
|
|
}
|
|
|
|
|
|
public static ServiceOfferingResponse createServiceOfferingResponse (ServiceOfferingVO offering) {
|
|
ServiceOfferingResponse offeringResponse = new ServiceOfferingResponse();
|
|
offeringResponse.setId(offering.getId());
|
|
offeringResponse.setName(offering.getName());
|
|
offeringResponse.setDisplayText(offering.getDisplayText());
|
|
offeringResponse.setCpuNumber(offering.getCpu());
|
|
offeringResponse.setCpuSpeed(offering.getSpeed());
|
|
offeringResponse.setMemory(offering.getRamSize());
|
|
offeringResponse.setCreated(offering.getCreated());
|
|
offeringResponse.setStorageType(offering.getUseLocalStorage() ? "local" : "shared");
|
|
offeringResponse.setOfferHa(offering.getOfferHA());
|
|
offeringResponse.setUseVirtualNetwork(offering.getGuestIpType().equals(GuestIpType.Virtualized));
|
|
offeringResponse.setTags(offering.getTags());
|
|
|
|
return offeringResponse;
|
|
}
|
|
|
|
public static ConfigurationResponse createConfigurationResponse (ConfigurationVO cfg) {
|
|
ConfigurationResponse cfgResponse = new ConfigurationResponse();
|
|
cfgResponse.setCategory(cfg.getCategory());
|
|
cfgResponse.setDescription(cfg.getDescription());
|
|
cfgResponse.setName(cfg.getName());
|
|
cfgResponse.setValue(cfg.getValue());
|
|
|
|
return cfgResponse;
|
|
}
|
|
|
|
public static SnapshotResponse createSnapshotResponse (Snapshot snapshot) {
|
|
SnapshotResponse snapshotResponse = new SnapshotResponse();
|
|
snapshotResponse.setId(snapshot.getId());
|
|
|
|
Account acct = ApiDBUtils.findAccountById(Long.valueOf(snapshot.getAccountId()));
|
|
if (acct != null) {
|
|
snapshotResponse.setAccountName(acct.getAccountName());
|
|
snapshotResponse.setDomainId(acct.getDomainId());
|
|
snapshotResponse.setDomainName(ApiDBUtils.findDomainById(acct.getDomainId()).getName());
|
|
}
|
|
|
|
VolumeVO volume = ApiDBUtils.findVolumeById(snapshot.getVolumeId());
|
|
String snapshotTypeStr = SnapshotType.values()[snapshot.getSnapshotType()].name();
|
|
snapshotResponse.setSnapshotType(snapshotTypeStr);
|
|
snapshotResponse.setVolumeId(snapshot.getVolumeId());
|
|
snapshotResponse.setVolumeName(volume.getName());
|
|
snapshotResponse.setVolumeType(volume.getVolumeType().name());
|
|
snapshotResponse.setCreated(snapshot.getCreated());
|
|
snapshotResponse.setName(snapshot.getName());
|
|
snapshotResponse.setIntervalType(ApiDBUtils.getSnapshotIntervalTypes(snapshot.getId()));
|
|
AsyncJobVO asyncJob = ApiDBUtils.findInstancePendingAsyncJob("snapshot", snapshot.getId());
|
|
if (asyncJob != null) {
|
|
snapshotResponse.setJobId(asyncJob.getId());
|
|
snapshotResponse.setJobStatus(asyncJob.getStatus());
|
|
}
|
|
return snapshotResponse;
|
|
}
|
|
|
|
|
|
public static SnapshotPolicyResponse createSnapshotPolicyResponse (SnapshotPolicyVO policy) {
|
|
SnapshotPolicyResponse policyResponse = new SnapshotPolicyResponse();
|
|
policyResponse.setId(policy.getId());
|
|
policyResponse.setVolumeId(policy.getVolumeId());
|
|
policyResponse.setSchedule(policy.getSchedule());
|
|
policyResponse.setIntervalType(policy.getInterval());
|
|
policyResponse.setMaxSnaps(policy.getMaxSnaps());
|
|
policyResponse.setTimezone(policy.getTimezone());
|
|
|
|
return policyResponse;
|
|
}
|
|
|
|
public static UserVmResponse createUserVmResponse (UserVm userVm) {
|
|
UserVmResponse userVmResponse = new UserVmResponse();
|
|
|
|
Account acct = ApiDBUtils.findAccountById(Long.valueOf(userVm.getAccountId()));
|
|
//FIXME - this check should be done in searchForUserVm method in ManagementServerImpl;
|
|
//otherwise the number of vms returned is not going to match pageSize request parameter
|
|
if ((acct != null) && (acct.getRemoved() == null)) {
|
|
userVmResponse.setAccountName(acct.getAccountName());
|
|
userVmResponse.setDomainId(acct.getDomainId());
|
|
userVmResponse.setDomainName(ApiDBUtils.findDomainById(acct.getDomainId()).getName());
|
|
} else {
|
|
return null; // the account has been deleted, skip this VM in the response
|
|
}
|
|
|
|
userVmResponse.setId(userVm.getId());
|
|
AsyncJobVO asyncJob = ApiDBUtils.findInstancePendingAsyncJob("vm_instance", userVm.getId());
|
|
if (asyncJob != null) {
|
|
userVmResponse.setJobId(asyncJob.getId());
|
|
userVmResponse.setJobStatus(asyncJob.getStatus());
|
|
}
|
|
|
|
userVmResponse.setName(userVm.getName());
|
|
userVmResponse.setCreated(userVm.getCreated());
|
|
userVmResponse.setIpAddress(userVm.getPrivateIpAddress());
|
|
if (userVm.getState() != null) {
|
|
userVmResponse.setState(userVm.getState().toString());
|
|
}
|
|
|
|
|
|
userVmResponse.setHaEnable(userVm.isHaEnabled());
|
|
|
|
if (userVm.getDisplayName() != null) {
|
|
userVmResponse.setDisplayName(userVm.getDisplayName());
|
|
} else {
|
|
userVmResponse.setDisplayName(userVm.getName());
|
|
}
|
|
|
|
InstanceGroupVO group = ApiDBUtils.findInstanceGroupForVM(userVm.getId());
|
|
if (group != null) {
|
|
userVmResponse.setGroup(group.getName());
|
|
userVmResponse.setGroupId(group.getId());
|
|
}
|
|
|
|
// Data Center Info
|
|
userVmResponse.setZoneId(userVm.getDataCenterId());
|
|
userVmResponse.setZoneName(ApiDBUtils.findZoneById(userVm.getDataCenterId()).getName());
|
|
|
|
Account account = (Account)UserContext.current().getAccount();
|
|
//if user is an admin, display host id
|
|
if (((account == null) || (account.getType() == Account.ACCOUNT_TYPE_ADMIN)) && (userVm.getHostId() != null)) {
|
|
userVmResponse.setHostId(userVm.getHostId());
|
|
userVmResponse.setHostName(ApiDBUtils.findHostById(userVm.getHostId()).getName());
|
|
}
|
|
|
|
// Template Info
|
|
VMTemplateVO template = ApiDBUtils.findTemplateById(userVm.getTemplateId());
|
|
if (template != null) {
|
|
userVmResponse.setTemplateId(userVm.getTemplateId());
|
|
userVmResponse.setTemplateName(template.getName());
|
|
userVmResponse.setTemplateDisplayText(template.getDisplayText());
|
|
userVmResponse.setPasswordEnabled(template.getEnablePassword());
|
|
} else {
|
|
userVmResponse.setTemplateId(-1L);
|
|
userVmResponse.setTemplateName("ISO Boot");
|
|
userVmResponse.setTemplateDisplayText("ISO Boot");
|
|
userVmResponse.setPasswordEnabled(false);
|
|
}
|
|
|
|
// ISO Info
|
|
if (userVm.getIsoId() != null) {
|
|
VMTemplateVO iso = ApiDBUtils.findTemplateById(userVm.getIsoId().longValue());
|
|
if (iso != null) {
|
|
userVmResponse.setIsoId(userVm.getIsoId());
|
|
userVmResponse.setIsoName(iso.getName());
|
|
}
|
|
}
|
|
|
|
// Service Offering Info
|
|
ServiceOffering offering = ApiDBUtils.findServiceOfferingById(userVm.getServiceOfferingId());
|
|
userVmResponse.setServiceOfferingId(userVm.getServiceOfferingId());
|
|
userVmResponse.setServiceOfferingName(offering.getName());
|
|
userVmResponse.setCpuNumber(offering.getCpu());
|
|
userVmResponse.setCpuSpeed(offering.getSpeed());
|
|
userVmResponse.setMemory(offering.getRamSize());
|
|
|
|
VolumeVO rootVolume = ApiDBUtils.findRootVolume(userVm.getId());
|
|
if (rootVolume != null) {
|
|
userVmResponse.setRootDeviceId(rootVolume.getDeviceId());
|
|
StoragePoolVO storagePool = ApiDBUtils.findStoragePoolById(rootVolume.getPoolId());
|
|
userVmResponse.setRootDeviceType(storagePool.getPoolType().toString());
|
|
}
|
|
|
|
//stats calculation
|
|
DecimalFormat decimalFormat = new DecimalFormat("#.##");
|
|
String cpuUsed = null;
|
|
VmStats vmStats = ApiDBUtils.getVmStatistics(userVm.getId());
|
|
if (vmStats != null) {
|
|
float cpuUtil = (float) vmStats.getCPUUtilization();
|
|
cpuUsed = decimalFormat.format(cpuUtil) + "%";
|
|
userVmResponse.setCpuUsed(cpuUsed);
|
|
|
|
long networkKbRead = (long)vmStats.getNetworkReadKBs();
|
|
userVmResponse.setNetworkKbsRead(networkKbRead);
|
|
|
|
long networkKbWrite = (long)vmStats.getNetworkWriteKBs();
|
|
userVmResponse.setNetworkKbsWrite(networkKbWrite);
|
|
}
|
|
|
|
userVmResponse.setGuestOsId(userVm.getGuestOSId());
|
|
//network groups
|
|
userVmResponse.setNetworkGroupList(ApiDBUtils.getNetworkGroupsNamesForVm(userVm.getId()));
|
|
|
|
return userVmResponse;
|
|
}
|
|
|
|
public static SystemVmResponse createSystemVmResponse (VMInstanceVO systemVM) {
|
|
SystemVmResponse vmResponse = new SystemVmResponse();
|
|
if (systemVM instanceof SystemVm) {
|
|
SystemVm vm = (SystemVm)systemVM;
|
|
|
|
vmResponse.setId(vm.getId());
|
|
vmResponse.setSystemVmType(vm.getType().toString().toLowerCase());
|
|
|
|
String instanceType = "console_proxy";
|
|
if (systemVM instanceof SecondaryStorageVmVO) {
|
|
instanceType = "sec_storage_vm"; // FIXME: this should be a constant so that the async jobs get updated with the correct instance type, they are using
|
|
// different instance types at the moment
|
|
}
|
|
|
|
AsyncJobVO asyncJob = ApiDBUtils.findInstancePendingAsyncJob(instanceType, vm.getId());
|
|
if (asyncJob != null) {
|
|
vmResponse.setJobId(asyncJob.getId());
|
|
vmResponse.setJobStatus(asyncJob.getStatus());
|
|
}
|
|
|
|
vmResponse.setZoneId(vm.getDataCenterId());
|
|
vmResponse.setZoneName(ApiDBUtils.findZoneById(vm.getDataCenterId()).getName());
|
|
vmResponse.setDns1(vm.getDns1());
|
|
vmResponse.setDns2(vm.getDns2());
|
|
vmResponse.setNetworkDomain(vm.getDomain());
|
|
vmResponse.setGateway(vm.getGateway());
|
|
vmResponse.setName(vm.getName());
|
|
vmResponse.setPodId(vm.getPodId());
|
|
if (vm.getHostId() != null) {
|
|
vmResponse.setHostId(vm.getHostId());
|
|
vmResponse.setHostName(ApiDBUtils.findHostById(vm.getHostId()).getName());
|
|
}
|
|
vmResponse.setPrivateIp(vm.getPrivateIpAddress());
|
|
vmResponse.setPrivateMacAddress(vm.getPrivateMacAddress());
|
|
vmResponse.setPrivateNetmask(vm.getPrivateNetmask());
|
|
vmResponse.setPublicIp(vm.getPublicIpAddress());
|
|
vmResponse.setPublicMacAddress(vm.getPublicMacAddress());
|
|
vmResponse.setPublicNetmask(vm.getPublicNetmask());
|
|
vmResponse.setTemplateId(vm.getTemplateId());
|
|
vmResponse.setCreated(vm.getCreated());
|
|
if (vm.getState() != null) {
|
|
vmResponse.setState(vm.getState().toString());
|
|
}
|
|
}
|
|
|
|
// for console proxies, add the active sessions
|
|
if (systemVM instanceof ConsoleProxyVO) {
|
|
ConsoleProxyVO proxy = (ConsoleProxyVO)systemVM;
|
|
vmResponse.setActiveViewerSessions(proxy.getActiveSession());
|
|
}
|
|
return vmResponse;
|
|
}
|
|
|
|
|
|
public static DomainRouterResponse createDomainRouterResponse (DomainRouter router) {
|
|
DomainRouterResponse routerResponse = new DomainRouterResponse();
|
|
routerResponse.setId(router.getId());
|
|
|
|
AsyncJobVO asyncJob = ApiDBUtils.findInstancePendingAsyncJob("domain_router", router.getId());
|
|
if (asyncJob != null) {
|
|
routerResponse.setJobId(asyncJob.getId());
|
|
routerResponse.setJobStatus(asyncJob.getStatus());
|
|
}
|
|
|
|
routerResponse.setZoneId(router.getDataCenterId());
|
|
routerResponse.setZoneName(ApiDBUtils.findZoneById(router.getDataCenterId()).getName());
|
|
routerResponse.setDns1(router.getDns1());
|
|
routerResponse.setDns2(router.getDns2());
|
|
routerResponse.setNetworkDomain(router.getDomain());
|
|
routerResponse.setGateway(router.getGateway());
|
|
routerResponse.setName(router.getName());
|
|
routerResponse.setPodId(router.getPodId());
|
|
|
|
if (router.getHostId() != null) {
|
|
routerResponse.setHostId(router.getHostId());
|
|
routerResponse.setHostName(ApiDBUtils.findHostById(router.getHostId()).getName());
|
|
}
|
|
|
|
routerResponse.setPrivateIp(router.getPrivateIpAddress());
|
|
routerResponse.setPrivateMacAddress(router.getPrivateMacAddress());
|
|
routerResponse.setPrivateNetmask(router.getPrivateNetmask());
|
|
routerResponse.setPublicIp(router.getPublicIpAddress());
|
|
routerResponse.setPublicMacAddress(router.getPublicMacAddress());
|
|
routerResponse.setPublicNetmask(router.getPublicNetmask());
|
|
routerResponse.setGuestIpAddress(router.getGuestIpAddress());
|
|
routerResponse.setGuestMacAddress(router.getGuestMacAddress());
|
|
routerResponse.setGuestNetmask(router.getGuestNetmask());
|
|
routerResponse.setTemplateId(router.getTemplateId());
|
|
routerResponse.setCreated(router.getCreated());
|
|
routerResponse.setState(router.getState());
|
|
|
|
Account accountTemp = ApiDBUtils.findAccountById(router.getAccountId());
|
|
if (accountTemp != null) {
|
|
routerResponse.setAccountName(accountTemp.getAccountName());
|
|
routerResponse.setDomainId(accountTemp.getDomainId());
|
|
routerResponse.setDomainName(ApiDBUtils.findDomainById(accountTemp.getDomainId()).getName());
|
|
}
|
|
|
|
return routerResponse;
|
|
}
|
|
|
|
public static HostResponse createHostResponse (HostVO host) {
|
|
HostResponse hostResponse = new HostResponse();
|
|
hostResponse.setId(host.getId());
|
|
hostResponse.setCapabilities(host.getCapabilities());
|
|
hostResponse.setClusterId(host.getClusterId());
|
|
hostResponse.setCpuNumber(host.getCpus());
|
|
hostResponse.setZoneId(host.getDataCenterId());
|
|
hostResponse.setDisconnectedOn(host.getDisconnectedOn());
|
|
hostResponse.setHypervisor(host.getHypervisorType());
|
|
hostResponse.setHostType(host.getType());
|
|
hostResponse.setLastPinged(new Date(host.getLastPinged()));
|
|
hostResponse.setManagementServerId(host.getManagementServerId());
|
|
hostResponse.setName(host.getName());
|
|
hostResponse.setPodId(host.getPodId());
|
|
hostResponse.setRemoved(host.getRemoved());
|
|
hostResponse.setCpuSpeed(host.getSpeed());
|
|
hostResponse.setState(host.getStatus());
|
|
hostResponse.setIpAddress(host.getPrivateIpAddress());
|
|
hostResponse.setVersion(host.getVersion());
|
|
hostResponse.setCreated(host.getCreated());
|
|
|
|
GuestOSCategoryVO guestOSCategory = ApiDBUtils.getHostGuestOSCategory(host.getId());
|
|
if (guestOSCategory != null) {
|
|
hostResponse.setOsCategoryId(guestOSCategory.getId());
|
|
hostResponse.setOsCategoryName(guestOSCategory.getName());
|
|
}
|
|
hostResponse.setZoneName(ApiDBUtils.findZoneById(host.getDataCenterId()).getName());
|
|
|
|
if (host.getPodId() != null) {
|
|
hostResponse.setPodName(ApiDBUtils.findPodById(host.getPodId()).getName());
|
|
}
|
|
|
|
DecimalFormat decimalFormat = new DecimalFormat("#.##");
|
|
|
|
// calculate cpu allocated by vm
|
|
if ((host.getCpus() != null) && (host.getSpeed() != null)) {
|
|
int cpu = 0;
|
|
String cpuAlloc = null;
|
|
List<UserVmVO> instances = ApiDBUtils.listUserVMsByHostId(host.getId());
|
|
for (UserVmVO vm : instances) {
|
|
ServiceOffering so = ApiDBUtils.findServiceOfferingById(vm.getServiceOfferingId());
|
|
cpu += so.getCpu() * so.getSpeed();
|
|
}
|
|
cpuAlloc = decimalFormat.format(((float) cpu / (float) (host.getCpus() * host.getSpeed())) * 100f) + "%";
|
|
hostResponse.setCpuAllocated(cpuAlloc);
|
|
}
|
|
|
|
// calculate cpu utilized
|
|
String cpuUsed = null;
|
|
HostStats hostStats = ApiDBUtils.getHostStatistics(host.getId());
|
|
if (hostStats != null) {
|
|
float cpuUtil = (float) hostStats.getCpuUtilization();
|
|
cpuUsed = decimalFormat.format(cpuUtil) + "%";
|
|
hostResponse.setCpuUsed(cpuUsed);
|
|
hostResponse.setAverageLoad((long)hostStats.getAverageLoad());
|
|
hostResponse.setNetworkKbsRead((long)hostStats.getNetworkReadKBs());
|
|
hostResponse.setNetworkKbsWrite((long)hostStats.getNetworkWriteKBs());
|
|
}
|
|
|
|
if (host.getType() == Host.Type.Routing) {
|
|
hostResponse.setMemoryTotal(host.getTotalMemory());
|
|
|
|
// calculate memory allocated by systemVM and userVm
|
|
long mem = ApiDBUtils.getMemoryUsagebyHost(host.getId());
|
|
hostResponse.setMemoryAllocated(mem);
|
|
hostResponse.setMemoryUsed(mem);
|
|
} else if (host.getType().toString().equals("Storage")) {
|
|
hostResponse.setDiskSizeTotal(host.getTotalSize());
|
|
hostResponse.setDiskSizeAllocated(0L);
|
|
}
|
|
|
|
if (host.getClusterId() != null) {
|
|
ClusterVO cluster = ApiDBUtils.findClusterById(host.getClusterId());
|
|
hostResponse.setClusterName(cluster.getName());
|
|
}
|
|
|
|
hostResponse.setLocalStorageActive(ApiDBUtils.isLocalStorageActiveOnHost(host));
|
|
|
|
Set<Event> possibleEvents = host.getStatus().getPossibleEvents();
|
|
if ((possibleEvents != null) && !possibleEvents.isEmpty()) {
|
|
String events = "";
|
|
Iterator<Event> iter = possibleEvents.iterator();
|
|
while (iter.hasNext()) {
|
|
Event event = iter.next();
|
|
events += event.toString();
|
|
if (iter.hasNext()) {
|
|
events += "; ";
|
|
}
|
|
}
|
|
hostResponse.setEvents(events);
|
|
}
|
|
|
|
return hostResponse;
|
|
}
|
|
}
|