mirror of https://github.com/apache/cloudstack.git
1306 lines
59 KiB
Java
1306 lines
59 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 org.apache.log4j.Logger;
|
|
|
|
import com.cloud.api.response.AccountResponse;
|
|
import com.cloud.api.response.ClusterResponse;
|
|
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.FirewallRuleResponse;
|
|
import com.cloud.api.response.HostResponse;
|
|
import com.cloud.api.response.IPAddressResponse;
|
|
import com.cloud.api.response.InstanceGroupResponse;
|
|
import com.cloud.api.response.IpForwardingRuleResponse;
|
|
import com.cloud.api.response.LoadBalancerResponse;
|
|
import com.cloud.api.response.PodResponse;
|
|
import com.cloud.api.response.PreallocatedLunResponse;
|
|
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.StoragePoolResponse;
|
|
import com.cloud.api.response.SystemVmResponse;
|
|
import com.cloud.api.response.UserResponse;
|
|
import com.cloud.api.response.UserVmResponse;
|
|
import com.cloud.api.response.VlanIpRangeResponse;
|
|
import com.cloud.api.response.VolumeResponse;
|
|
import com.cloud.api.response.ZoneResponse;
|
|
import com.cloud.async.AsyncJobVO;
|
|
import com.cloud.configuration.ConfigurationVO;
|
|
import com.cloud.configuration.ResourceCount.ResourceType;
|
|
import com.cloud.configuration.ResourceLimit;
|
|
import com.cloud.dc.ClusterVO;
|
|
import com.cloud.dc.DataCenter;
|
|
import com.cloud.dc.DataCenterVO;
|
|
import com.cloud.dc.HostPodVO;
|
|
import com.cloud.dc.Vlan.VlanType;
|
|
import com.cloud.dc.VlanVO;
|
|
import com.cloud.domain.DomainVO;
|
|
import com.cloud.exception.InvalidParameterValueException;
|
|
import com.cloud.host.Host;
|
|
import com.cloud.host.HostStats;
|
|
import com.cloud.host.HostVO;
|
|
import com.cloud.host.Status.Event;
|
|
import com.cloud.network.FirewallRuleVO;
|
|
import com.cloud.network.IPAddressVO;
|
|
import com.cloud.network.LoadBalancerVO;
|
|
import com.cloud.network.Networks.TrafficType;
|
|
import com.cloud.network.Network;
|
|
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.StorageStats;
|
|
import com.cloud.storage.VMTemplateVO;
|
|
import com.cloud.storage.Volume;
|
|
import com.cloud.storage.VolumeVO;
|
|
import com.cloud.storage.preallocatedlun.PreallocatedLunVO;
|
|
import com.cloud.test.PodZoneConfig;
|
|
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.Nic;
|
|
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.VirtualMachine;
|
|
import com.cloud.vm.VmStats;
|
|
|
|
public class ApiResponseHelper {
|
|
|
|
public static final Logger s_logger = Logger.getLogger(ApiResponseHelper.class.getName());
|
|
|
|
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());
|
|
userResponse.setObjectName("user");
|
|
|
|
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());
|
|
accountResponse.setState(account.getState());
|
|
|
|
//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);
|
|
accountResponse.setObjectName("account");
|
|
|
|
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);
|
|
}
|
|
domainResponse.setObjectName("domain");
|
|
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());
|
|
diskOfferingResponse.setCustomized(offering.isCustomized());
|
|
diskOfferingResponse.setObjectName("diskoffering");
|
|
return diskOfferingResponse;
|
|
}
|
|
|
|
public static ResourceLimitResponse createResourceLimitResponse (ResourceLimit 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());
|
|
resourceLimitResponse.setObjectName("resourcelimit");
|
|
|
|
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());
|
|
offeringResponse.setObjectName("serviceoffering");
|
|
|
|
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());
|
|
cfgResponse.setObjectName("configuration");
|
|
|
|
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());
|
|
}
|
|
snapshotResponse.setObjectName("snapshot");
|
|
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());
|
|
policyResponse.setObjectName("snapshotpolicy");
|
|
|
|
return policyResponse;
|
|
}
|
|
|
|
public static UserVmResponse createUserVmResponse (UserVm userVm) {
|
|
if (userVm.getPrivateIpAddress() == null) {
|
|
return createUserVm2Response(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.getHostName());
|
|
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.getHostName());
|
|
}
|
|
|
|
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 = 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);
|
|
}
|
|
|
|
if (userVm.getPassword() != null) {
|
|
userVmResponse.setPassword(userVm.getPassword());
|
|
}
|
|
|
|
// 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());
|
|
userVmResponse.setForVirtualNetwork(offering.getGuestIpType().equals(GuestIpType.Virtualized));
|
|
|
|
VolumeVO rootVolume = ApiDBUtils.findRootVolume(userVm.getId());
|
|
if (rootVolume != null) {
|
|
userVmResponse.setRootDeviceId(rootVolume.getDeviceId());
|
|
String rootDeviceType = "Not created";
|
|
if (rootVolume.getPoolId() != null){
|
|
StoragePoolVO storagePool = ApiDBUtils.findStoragePoolById(rootVolume.getPoolId());
|
|
rootDeviceType = storagePool.getPoolType().toString();
|
|
}
|
|
userVmResponse.setRootDeviceType(rootDeviceType);
|
|
}
|
|
|
|
//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()));
|
|
userVmResponse.setObjectName("virtualmachine");
|
|
return userVmResponse;
|
|
}
|
|
|
|
public static SystemVmResponse createSystemVmResponse (VirtualMachine systemVM) {
|
|
if (systemVM.getPrivateIpAddress() == null) {
|
|
return createSystemVm2Response(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.getHostName());
|
|
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());
|
|
}
|
|
vmResponse.setObjectName("systemvm");
|
|
return vmResponse;
|
|
}
|
|
|
|
|
|
public static DomainRouterResponse createDomainRouterResponse (DomainRouter router) {
|
|
if (router.getPrivateIpAddress() == null) {
|
|
return createDomainRouter2Response(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.getHostName());
|
|
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());
|
|
}
|
|
routerResponse.setObjectName("domainrouter");
|
|
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);
|
|
}
|
|
hostResponse.setObjectName("host");
|
|
|
|
return hostResponse;
|
|
}
|
|
|
|
public static VlanIpRangeResponse createVlanIpRangeResponse (VlanVO vlan) {
|
|
Long accountId = ApiDBUtils.getAccountIdForVlan(vlan.getId());
|
|
Long podId = ApiDBUtils.getPodIdForVlan(vlan.getId());
|
|
|
|
VlanIpRangeResponse vlanResponse = new VlanIpRangeResponse();
|
|
vlanResponse.setId(vlan.getId());
|
|
vlanResponse.setForVirtualNetwork(vlan.getVlanType().equals(VlanType.VirtualNetwork));
|
|
vlanResponse.setVlan(vlan.getVlanId());
|
|
vlanResponse.setZoneId(vlan.getDataCenterId());
|
|
|
|
if (accountId != null) {
|
|
Account account = ApiDBUtils.findAccountById(accountId);
|
|
vlanResponse.setAccountName(account.getAccountName());
|
|
vlanResponse.setDomainId(account.getDomainId());
|
|
vlanResponse.setDomainName(ApiDBUtils.findDomainById(account.getDomainId()).getName());
|
|
}
|
|
|
|
if (podId != null) {
|
|
HostPodVO pod = ApiDBUtils.findPodById(podId);
|
|
vlanResponse.setPodId(podId);
|
|
vlanResponse.setPodName(pod.getName());
|
|
}
|
|
|
|
vlanResponse.setGateway(vlan.getVlanGateway());
|
|
vlanResponse.setNetmask(vlan.getVlanNetmask());
|
|
vlanResponse.setDescription(vlan.getIpRange());
|
|
vlanResponse.setObjectName("vlan");
|
|
|
|
return vlanResponse;
|
|
}
|
|
|
|
public static IPAddressResponse createIPAddressResponse (IPAddressVO ipAddress) {
|
|
VlanVO vlan = ApiDBUtils.findVlanById(ipAddress.getVlanDbId());
|
|
boolean forVirtualNetworks = vlan.getVlanType().equals(VlanType.VirtualNetwork);
|
|
|
|
IPAddressResponse ipResponse = new IPAddressResponse();
|
|
ipResponse.setIpAddress(ipAddress.getAddress());
|
|
if (ipAddress.getAllocated() != null) {
|
|
ipResponse.setAllocated(ipAddress.getAllocated());
|
|
}
|
|
ipResponse.setZoneId(ipAddress.getDataCenterId());
|
|
ipResponse.setZoneName(ApiDBUtils.findZoneById(ipAddress.getDataCenterId()).getName());
|
|
ipResponse.setSourceNat(ipAddress.isSourceNat());
|
|
|
|
//get account information
|
|
Account accountTemp = ApiDBUtils.findAccountById(ipAddress.getAccountId());
|
|
if (accountTemp !=null){
|
|
ipResponse.setAccountName(accountTemp.getAccountName());
|
|
ipResponse.setDomainId(accountTemp.getDomainId());
|
|
ipResponse.setDomainName(ApiDBUtils.findDomainById(accountTemp.getDomainId()).getName());
|
|
}
|
|
|
|
ipResponse.setForVirtualNetwork(forVirtualNetworks);
|
|
ipResponse.setStaticNat(ipAddress.isOneToOneNat());
|
|
|
|
//show this info to admin only
|
|
Account account = UserContext.current().getAccount();
|
|
if ((account == null) || account.getType() == Account.ACCOUNT_TYPE_ADMIN) {
|
|
ipResponse.setVlanId(ipAddress.getVlanDbId());
|
|
ipResponse.setVlanName(ApiDBUtils.findVlanById(ipAddress.getVlanDbId()).getVlanId());
|
|
}
|
|
ipResponse.setObjectName("ipaddress");
|
|
return ipResponse;
|
|
}
|
|
|
|
public static LoadBalancerResponse createLoadBalancerResponse (LoadBalancerVO loadBalancer) {
|
|
LoadBalancerResponse lbResponse = new LoadBalancerResponse();
|
|
lbResponse.setId(loadBalancer.getId());
|
|
lbResponse.setName(loadBalancer.getName());
|
|
lbResponse.setDescription(loadBalancer.getDescription());
|
|
lbResponse.setPublicIp(loadBalancer.getIpAddress());
|
|
lbResponse.setPublicPort(loadBalancer.getPublicPort());
|
|
lbResponse.setPrivatePort(loadBalancer.getPrivatePort());
|
|
lbResponse.setAlgorithm(loadBalancer.getAlgorithm());
|
|
|
|
Account accountTemp = ApiDBUtils.findAccountById(loadBalancer.getAccountId());
|
|
if (accountTemp != null) {
|
|
lbResponse.setAccountName(accountTemp.getAccountName());
|
|
lbResponse.setDomainId(accountTemp.getDomainId());
|
|
lbResponse.setDomainName(ApiDBUtils.findDomainById(accountTemp.getDomainId()).getName());
|
|
}
|
|
lbResponse.setObjectName("loadbalancer");
|
|
return lbResponse;
|
|
}
|
|
|
|
public static PodResponse createPodResponse (HostPodVO pod) {
|
|
String[] ipRange = new String[2];
|
|
if (pod.getDescription() != null && pod.getDescription().length() > 0) {
|
|
ipRange = pod.getDescription().split("-");
|
|
} else {
|
|
ipRange[0] = pod.getDescription();
|
|
}
|
|
|
|
PodResponse podResponse = new PodResponse();
|
|
podResponse.setId(pod.getId());
|
|
podResponse.setName(pod.getName());
|
|
podResponse.setZoneId(pod.getDataCenterId());
|
|
podResponse.setZoneName(PodZoneConfig.getZoneName(pod.getDataCenterId()));
|
|
podResponse.setCidr(pod.getCidrAddress() +"/" + pod.getCidrSize());
|
|
podResponse.setStartIp(ipRange[0]);
|
|
podResponse.setEndIp(((ipRange.length > 1) && (ipRange[1] != null)) ? ipRange[1] : "");
|
|
podResponse.setGateway(pod.getGateway());
|
|
podResponse.setObjectName("pod");
|
|
return podResponse;
|
|
}
|
|
|
|
public static ZoneResponse createZoneResponse (DataCenterVO dataCenter) {
|
|
Account account = UserContext.current().getAccount();
|
|
ZoneResponse zoneResponse = new ZoneResponse();
|
|
zoneResponse.setId(dataCenter.getId());
|
|
zoneResponse.setName(dataCenter.getName());
|
|
|
|
if ((dataCenter.getDescription() != null) && !dataCenter.getDescription().equalsIgnoreCase("null")) {
|
|
zoneResponse.setDescription(dataCenter.getDescription());
|
|
}
|
|
|
|
if ((account == null) || (account.getType() == Account.ACCOUNT_TYPE_ADMIN)) {
|
|
zoneResponse.setDns1(dataCenter.getDns1());
|
|
zoneResponse.setDns2(dataCenter.getDns2());
|
|
zoneResponse.setInternalDns1(dataCenter.getInternalDns1());
|
|
zoneResponse.setInternalDns2(dataCenter.getInternalDns2());
|
|
zoneResponse.setVlan(dataCenter.getVnet());
|
|
zoneResponse.setGuestCidrAddress(dataCenter.getGuestNetworkCidr());
|
|
}
|
|
|
|
zoneResponse.setDomain(dataCenter.getDomain());
|
|
zoneResponse.setDomainId(dataCenter.getDomainId());
|
|
zoneResponse.setType(dataCenter.getNetworkType().toString());
|
|
zoneResponse.setObjectName("zone");
|
|
return zoneResponse;
|
|
}
|
|
|
|
public static VolumeResponse createVolumeResponse(VolumeVO volume) {
|
|
VolumeResponse volResponse = new VolumeResponse();
|
|
volResponse.setId(volume.getId());
|
|
|
|
AsyncJobVO asyncJob = ApiDBUtils.findInstancePendingAsyncJob("volume", volume.getId());
|
|
if (asyncJob != null) {
|
|
volResponse.setJobId(asyncJob.getId());
|
|
volResponse.setJobStatus(asyncJob.getStatus());
|
|
}
|
|
|
|
if (volume.getName() != null) {
|
|
volResponse.setName(volume.getName());
|
|
} else {
|
|
volResponse.setName("");
|
|
}
|
|
|
|
volResponse.setZoneId(volume.getDataCenterId());
|
|
volResponse.setZoneName(ApiDBUtils.findZoneById(volume.getDataCenterId()).getName());
|
|
|
|
volResponse.setVolumeType(volume.getVolumeType().toString());
|
|
volResponse.setDeviceId(volume.getDeviceId());
|
|
|
|
Long instanceId = volume.getInstanceId();
|
|
if (instanceId != null) {
|
|
VMInstanceVO vm = ApiDBUtils.findVMInstanceById(instanceId);
|
|
volResponse.setVirtualMachineId(vm.getId());
|
|
volResponse.setVirtualMachineName(vm.getHostName());
|
|
volResponse.setVirtualMachineDisplayName(vm.getHostName());
|
|
volResponse.setVirtualMachineState(vm.getState().toString());
|
|
}
|
|
|
|
// Show the virtual size of the volume
|
|
volResponse.setSize(volume.getSize());
|
|
|
|
volResponse.setCreated(volume.getCreated());
|
|
volResponse.setState(volume.getStatus().toString());
|
|
|
|
Account accountTemp = ApiDBUtils.findAccountById(volume.getAccountId());
|
|
if (accountTemp != null) {
|
|
volResponse.setAccountName(accountTemp.getAccountName());
|
|
volResponse.setDomainId(accountTemp.getDomainId());
|
|
volResponse.setDomainName(ApiDBUtils.findDomainById(accountTemp.getDomainId()).getName());
|
|
}
|
|
|
|
String storageType;
|
|
try {
|
|
if(volume.getPoolId() == null){
|
|
if (volume.getState() == Volume.State.Allocated) {
|
|
/*set it as shared, so the UI can attach it to VM*/
|
|
storageType = "shared";
|
|
} else {
|
|
storageType = "unknown";
|
|
}
|
|
} else {
|
|
storageType = ApiDBUtils.volumeIsOnSharedStorage(volume.getId()) ? "shared" : "local";
|
|
}
|
|
} catch (InvalidParameterValueException e) {
|
|
s_logger.error(e.getMessage(), e);
|
|
throw new ServerApiException(BaseCmd.INTERNAL_ERROR, "Volume " + volume.getName() + " does not have a valid ID");
|
|
}
|
|
|
|
volResponse.setStorageType(storageType);
|
|
if(volume.getVolumeType().equals(Volume.VolumeType.ROOT)){
|
|
volResponse.setServiceOfferingId(volume.getDiskOfferingId());
|
|
}else{
|
|
volResponse.setDiskOfferingId(volume.getDiskOfferingId());
|
|
}
|
|
|
|
DiskOfferingVO diskOffering = ApiDBUtils.findDiskOfferingById(volume.getDiskOfferingId());
|
|
if(volume.getVolumeType().equals(Volume.VolumeType.ROOT)){
|
|
volResponse.setServiceOfferingName(diskOffering.getName());
|
|
volResponse.setServiceOfferingDisplayText(diskOffering.getDisplayText());
|
|
}else{
|
|
volResponse.setDiskOfferingName(diskOffering.getName());
|
|
volResponse.setDiskOfferingDisplayText(diskOffering.getDisplayText());
|
|
}
|
|
|
|
Long poolId = volume.getPoolId();
|
|
String poolName = (poolId == null) ? "none" : ApiDBUtils.findStoragePoolById(poolId).getName();
|
|
volResponse.setStoragePoolName(poolName);
|
|
volResponse.setSourceId(volume.getSourceId());
|
|
if (volume.getSourceType() != null) {
|
|
volResponse.setSourceType(volume.getSourceType().toString());
|
|
}
|
|
volResponse.setHypervisor(ApiDBUtils.getVolumeHyperType(volume.getId()).toString());
|
|
volResponse.setAttached(volume.getAttached());
|
|
volResponse.setDestroyed(volume.getDestroyed());
|
|
volResponse.setObjectName("volume");
|
|
return volResponse;
|
|
}
|
|
|
|
|
|
public static InstanceGroupResponse createInstanceGroupResponse(InstanceGroupVO group) {
|
|
InstanceGroupResponse groupResponse = new InstanceGroupResponse();
|
|
groupResponse.setId(group.getId());
|
|
groupResponse.setName(group.getName());
|
|
groupResponse.setCreated(group.getCreated());
|
|
|
|
Account accountTemp = ApiDBUtils.findAccountById(group.getAccountId());
|
|
if (accountTemp != null) {
|
|
groupResponse.setAccountName(accountTemp.getAccountName());
|
|
groupResponse.setDomainId(accountTemp.getDomainId());
|
|
groupResponse.setDomainName(ApiDBUtils.findDomainById(accountTemp.getDomainId()).getName());
|
|
}
|
|
groupResponse.setObjectName("instancegroup");
|
|
return groupResponse;
|
|
}
|
|
|
|
public static PreallocatedLunResponse createPreallocatedLunResponse(PreallocatedLunVO preallocatedLun) {
|
|
PreallocatedLunResponse preallocLunResponse = new PreallocatedLunResponse();
|
|
preallocLunResponse.setId(preallocatedLun.getId());
|
|
preallocLunResponse.setVolumeId(preallocatedLun.getVolumeId());
|
|
preallocLunResponse.setZoneId(preallocatedLun.getDataCenterId());
|
|
preallocLunResponse.setLun(preallocatedLun.getLun());
|
|
preallocLunResponse.setPortal(preallocatedLun.getPortal());
|
|
preallocLunResponse.setSize(preallocatedLun.getSize());
|
|
preallocLunResponse.setTaken(preallocatedLun.getTaken());
|
|
preallocLunResponse.setTargetIqn(preallocatedLun.getTargetIqn());
|
|
preallocLunResponse.setObjectName("preallocatedlun");
|
|
return preallocLunResponse;
|
|
}
|
|
|
|
public static StoragePoolResponse createStoragePoolResponse(StoragePoolVO pool) {
|
|
StoragePoolResponse poolResponse = new StoragePoolResponse();
|
|
poolResponse.setId(pool.getId());
|
|
poolResponse.setName(pool.getName());
|
|
poolResponse.setState(pool.getStatus());
|
|
poolResponse.setPath(pool.getPath());
|
|
poolResponse.setIpAddress(pool.getHostAddress());
|
|
poolResponse.setZoneId(pool.getDataCenterId());
|
|
poolResponse.setZoneName(ApiDBUtils.findZoneById(pool.getDataCenterId()).getName());
|
|
if (pool.getPoolType() != null) {
|
|
poolResponse.setType(pool.getPoolType().toString());
|
|
}
|
|
if (pool.getPodId() != null) {
|
|
poolResponse.setPodId(pool.getPodId());
|
|
poolResponse.setPodName(ApiDBUtils.findPodById(pool.getPodId()).getName());
|
|
}
|
|
if (pool.getCreated() != null) {
|
|
poolResponse.setCreated(pool.getCreated());
|
|
}
|
|
|
|
StorageStats stats = ApiDBUtils.getStoragePoolStatistics(pool.getId());
|
|
long capacity = pool.getCapacityBytes();
|
|
long available = pool.getAvailableBytes() ;
|
|
long used = capacity - available;
|
|
|
|
if (stats != null) {
|
|
used = stats.getByteUsed();
|
|
available = capacity - used;
|
|
}
|
|
|
|
poolResponse.setDiskSizeTotal(pool.getCapacityBytes());
|
|
poolResponse.setDiskSizeAllocated(used);
|
|
|
|
if (pool.getClusterId() != null) {
|
|
ClusterVO cluster = ApiDBUtils.findClusterById(pool.getClusterId());
|
|
poolResponse.setClusterId(cluster.getId());
|
|
poolResponse.setClusterName(cluster.getName());
|
|
}
|
|
poolResponse.setTags(ApiDBUtils.getStoragePoolTags(pool.getId()));
|
|
poolResponse.setObjectName("storagepool");
|
|
return poolResponse;
|
|
}
|
|
|
|
|
|
public static ClusterResponse createClusterResponse(ClusterVO cluster) {
|
|
ClusterResponse clusterResponse = new ClusterResponse();
|
|
clusterResponse.setId(cluster.getId());
|
|
clusterResponse.setName(cluster.getName());
|
|
clusterResponse.setPodId(cluster.getPodId());
|
|
clusterResponse.setZoneId(cluster.getDataCenterId());
|
|
HostPodVO pod = ApiDBUtils.findPodById(cluster.getPodId());
|
|
clusterResponse.setPodName(pod.getName());
|
|
DataCenterVO zone = ApiDBUtils.findZoneById(cluster.getDataCenterId());
|
|
clusterResponse.setZoneName(zone.getName());
|
|
clusterResponse.setObjectName("cluster");
|
|
return clusterResponse;
|
|
}
|
|
|
|
public static FirewallRuleResponse createFirewallRuleResponse(FirewallRuleVO fwRule) {
|
|
FirewallRuleResponse response = new FirewallRuleResponse();
|
|
response.setId(fwRule.getId());
|
|
response.setPrivatePort(fwRule.getPrivatePort());
|
|
response.setProtocol(fwRule.getProtocol());
|
|
response.setPublicPort(fwRule.getPublicPort());
|
|
response.setPublicIpAddress(fwRule.getPublicIpAddress());
|
|
if (fwRule.getPublicIpAddress() != null && fwRule.getPrivateIpAddress() != null) {
|
|
UserVm vm = ApiDBUtils.findUserVmByPublicIpAndGuestIp(fwRule.getPublicIpAddress(), fwRule.getPrivateIpAddress());
|
|
response.setVirtualMachineId(vm.getId());
|
|
response.setVirtualMachineName(vm.getHostName());
|
|
response.setVirtualMachineDisplayName(vm.getDisplayName());
|
|
}
|
|
response.setObjectName("portforwardingrule");
|
|
return response;
|
|
}
|
|
|
|
public static IpForwardingRuleResponse createIpForwardingRuleResponse(FirewallRuleVO fwRule) {
|
|
IpForwardingRuleResponse response = new IpForwardingRuleResponse();
|
|
response.setId(fwRule.getId());
|
|
response.setPrivatePort(fwRule.getPrivatePort());
|
|
response.setProtocol(fwRule.getProtocol());
|
|
response.setPublicPort(fwRule.getPublicPort());
|
|
response.setPublicIpAddress(fwRule.getPublicIpAddress());
|
|
if (fwRule.getPublicIpAddress() != null && fwRule.getPrivateIpAddress() != null) {
|
|
UserVm vm = ApiDBUtils.findUserVmByPublicIpAndGuestIp(fwRule.getPublicIpAddress(), fwRule.getPrivateIpAddress());
|
|
response.setVirtualMachineId(vm.getId());
|
|
response.setVirtualMachineName(vm.getHostName());
|
|
response.setVirtualMachineDisplayName(vm.getDisplayName());
|
|
}
|
|
response.setObjectName("ipforwardingrule");
|
|
return response;
|
|
}
|
|
|
|
|
|
public static UserVmResponse createUserVm2Response (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.getHostName());
|
|
userVmResponse.setCreated(userVm.getCreated());
|
|
|
|
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.getHostName());
|
|
}
|
|
|
|
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 = 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);
|
|
}
|
|
|
|
if (userVm.getPassword() != null) {
|
|
userVmResponse.setPassword(userVm.getPassword());
|
|
}
|
|
|
|
// 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());
|
|
String rootDeviceType = "Not created";
|
|
if (rootVolume.getPoolId() != null){
|
|
StoragePoolVO storagePool = ApiDBUtils.findStoragePoolById(rootVolume.getPoolId());
|
|
rootDeviceType = storagePool.getPoolType().toString();
|
|
}
|
|
userVmResponse.setRootDeviceType(rootDeviceType);
|
|
}
|
|
|
|
//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()));
|
|
|
|
List<? extends Nic> nics = BaseCmd._networkMgr.getNics(userVm);
|
|
for (Nic singleNic : nics) {
|
|
long configId = singleNic.getNetworkId();
|
|
Network networkConf = BaseCmd._networkMgr.getNetworkConfiguration(configId);
|
|
if (networkConf.getTrafficType() == TrafficType.Guest) {
|
|
userVmResponse.setIpAddress(singleNic.getIp4Address());
|
|
}
|
|
}
|
|
|
|
userVmResponse.setObjectName("virtualmachine");
|
|
return userVmResponse;
|
|
}
|
|
|
|
|
|
public static DomainRouterResponse createDomainRouter2Response (DomainRouter router) {
|
|
DomainRouterResponse routerResponse = new DomainRouterResponse();
|
|
routerResponse.setId(router.getId());
|
|
routerResponse.setZoneId(router.getDataCenterId());
|
|
routerResponse.setName(router.getHostName());
|
|
routerResponse.setPodId(router.getPodId());
|
|
routerResponse.setTemplateId(router.getTemplateId());
|
|
routerResponse.setCreated(router.getCreated());
|
|
routerResponse.setState(router.getState());
|
|
routerResponse.setNetworkDomain(router.getDomain());
|
|
|
|
if (router.getHostId() != null) {
|
|
routerResponse.setHostId(router.getHostId());
|
|
routerResponse.setHostName(ApiDBUtils.findHostById(router.getHostId()).getName());
|
|
}
|
|
|
|
Account accountTemp = ApiDBUtils.findAccountById(router.getAccountId());
|
|
if (accountTemp != null) {
|
|
routerResponse.setAccountName(accountTemp.getAccountName());
|
|
routerResponse.setDomainId(accountTemp.getDomainId());
|
|
routerResponse.setDomainName(ApiDBUtils.findDomainById(accountTemp.getDomainId()).getName());
|
|
}
|
|
|
|
AsyncJobVO asyncJob = ApiDBUtils.findInstancePendingAsyncJob("domain_router", router.getId());
|
|
if (asyncJob != null) {
|
|
routerResponse.setJobId(asyncJob.getId());
|
|
routerResponse.setJobStatus(asyncJob.getStatus());
|
|
}
|
|
|
|
List<? extends Nic> nics = BaseCmd._networkMgr.getNics(router);
|
|
for (Nic singleNic : nics) {
|
|
long configId = singleNic.getNetworkId();
|
|
Network networkConf = BaseCmd._networkMgr.getNetworkConfiguration(configId);
|
|
|
|
if (networkConf.getTrafficType() == TrafficType.Guest) {
|
|
routerResponse.setGuestIpAddress(singleNic.getIp4Address());
|
|
routerResponse.setGuestMacAddress(singleNic.getMacAddress());
|
|
routerResponse.setGuestNetmask(singleNic.getNetmask());
|
|
}
|
|
|
|
if (networkConf.getTrafficType() == TrafficType.Control) {
|
|
routerResponse.setPrivateIp(singleNic.getIp4Address());
|
|
routerResponse.setPrivateMacAddress(singleNic.getMacAddress());
|
|
routerResponse.setPrivateNetmask(singleNic.getNetmask());
|
|
}
|
|
|
|
if (networkConf.getTrafficType() == TrafficType.Public) {
|
|
routerResponse.setPublicIp(singleNic.getIp4Address());
|
|
routerResponse.setPublicMacAddress(singleNic.getMacAddress());
|
|
routerResponse.setPublicNetmask(singleNic.getNetmask());
|
|
routerResponse.setGateway(singleNic.getGateway());
|
|
}
|
|
|
|
DataCenter zone = ApiDBUtils.findZoneById(router.getDataCenterId());
|
|
if (zone != null) {
|
|
routerResponse.setZoneName(zone.getName());
|
|
routerResponse.setDns1(zone.getDns1());
|
|
routerResponse.setDns2(zone.getDns2());
|
|
}
|
|
}
|
|
|
|
routerResponse.setObjectName("domainrouter");
|
|
return routerResponse;
|
|
}
|
|
|
|
|
|
public static SystemVmResponse createSystemVm2Response (VirtualMachine systemVM) {
|
|
SystemVmResponse vmResponse = new SystemVmResponse();
|
|
if (systemVM instanceof SystemVm) {
|
|
SystemVm vm = (SystemVm)systemVM;
|
|
|
|
vmResponse.setId(vm.getId());
|
|
vmResponse.setSystemVmType(vm.getType().toString().toLowerCase());
|
|
vmResponse.setZoneId(vm.getDataCenterId());
|
|
|
|
vmResponse.setNetworkDomain(vm.getDomain());
|
|
vmResponse.setName(vm.getHostName());
|
|
vmResponse.setPodId(vm.getPodId());
|
|
vmResponse.setTemplateId(vm.getTemplateId());
|
|
vmResponse.setCreated(vm.getCreated());
|
|
|
|
if (vm.getHostId() != null) {
|
|
vmResponse.setHostId(vm.getHostId());
|
|
vmResponse.setHostName(ApiDBUtils.findHostById(vm.getHostId()).getName());
|
|
}
|
|
|
|
if (vm.getState() != null) {
|
|
vmResponse.setState(vm.getState().toString());
|
|
}
|
|
|
|
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());
|
|
}
|
|
|
|
// for console proxies, add the active sessions
|
|
if (systemVM instanceof ConsoleProxyVO) {
|
|
ConsoleProxyVO proxy = (ConsoleProxyVO)systemVM;
|
|
vmResponse.setActiveViewerSessions(proxy.getActiveSession());
|
|
}
|
|
|
|
DataCenter zone = ApiDBUtils.findZoneById(vm.getDataCenterId());
|
|
if (zone != null) {
|
|
vmResponse.setZoneName(zone.getName());
|
|
vmResponse.setDns1(zone.getDns1());
|
|
vmResponse.setDns2(zone.getDns2());
|
|
}
|
|
|
|
List<? extends Nic> nics = BaseCmd._networkMgr.getNics(systemVM);
|
|
for (Nic singleNic : nics) {
|
|
long configId = singleNic.getNetworkId();
|
|
Network networkConf = BaseCmd._networkMgr.getNetworkConfiguration(configId);
|
|
|
|
if (networkConf.getTrafficType() == TrafficType.Management) {
|
|
vmResponse.setPrivateIp(singleNic.getIp4Address());
|
|
vmResponse.setPrivateMacAddress(singleNic.getMacAddress());
|
|
vmResponse.setPrivateNetmask(singleNic.getNetmask());
|
|
}
|
|
|
|
if (networkConf.getTrafficType() == TrafficType.Public) {
|
|
vmResponse.setPublicIp(singleNic.getIp4Address());
|
|
vmResponse.setPublicMacAddress(singleNic.getMacAddress());
|
|
vmResponse.setPublicNetmask(singleNic.getNetmask());
|
|
vmResponse.setGateway(singleNic.getGateway());
|
|
}
|
|
}
|
|
}
|
|
|
|
vmResponse.setObjectName("systemvm");
|
|
return vmResponse;
|
|
}
|
|
}
|