| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| package com.cloud.api; |
| |
| import static java.util.Collections.emptyList; |
| import static java.util.Collections.singletonList; |
| |
| import java.text.DecimalFormat; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Hashtable; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| |
| import org.apache.log4j.Logger; |
| |
| import com.cloud.acl.ControlledEntity; |
| import com.cloud.acl.ControlledEntity.ACLType; |
| import com.cloud.api.ApiConstants.HostDetails; |
| import com.cloud.api.ApiConstants.VMDetails; |
| import com.cloud.api.commands.QueryAsyncJobResultCmd; |
| import com.cloud.api.response.AccountResponse; |
| import com.cloud.api.response.ApiResponseSerializer; |
| import com.cloud.api.response.AsyncJobResponse; |
| import com.cloud.api.response.AutoScalePolicyResponse; |
| import com.cloud.api.response.AutoScaleVmGroupResponse; |
| import com.cloud.api.response.AutoScaleVmProfileResponse; |
| import com.cloud.api.response.CapabilityResponse; |
| import com.cloud.api.response.CapacityResponse; |
| import com.cloud.api.response.ClusterResponse; |
| import com.cloud.api.response.ConditionResponse; |
| import com.cloud.api.response.ConfigurationResponse; |
| import com.cloud.api.response.ControlledEntityResponse; |
| import com.cloud.api.response.CounterResponse; |
| import com.cloud.api.response.CreateCmdResponse; |
| import com.cloud.api.response.DiskOfferingResponse; |
| import com.cloud.api.response.DomainResponse; |
| import com.cloud.api.response.DomainRouterResponse; |
| import com.cloud.api.response.EventResponse; |
| import com.cloud.api.response.ExtractResponse; |
| import com.cloud.api.response.FirewallResponse; |
| import com.cloud.api.response.FirewallRuleResponse; |
| import com.cloud.api.response.HostResponse; |
| import com.cloud.api.response.HypervisorCapabilitiesResponse; |
| import com.cloud.api.response.IPAddressResponse; |
| import com.cloud.api.response.InstanceGroupResponse; |
| import com.cloud.api.response.IpForwardingRuleResponse; |
| import com.cloud.api.response.LBStickinessPolicyResponse; |
| import com.cloud.api.response.LBStickinessResponse; |
| import com.cloud.api.response.LDAPConfigResponse; |
| import com.cloud.api.response.ListResponse; |
| import com.cloud.api.response.LoadBalancerResponse; |
| import com.cloud.api.response.NetworkACLResponse; |
| import com.cloud.api.response.NetworkOfferingResponse; |
| import com.cloud.api.response.NetworkResponse; |
| import com.cloud.api.response.NicResponse; |
| import com.cloud.api.response.PhysicalNetworkResponse; |
| import com.cloud.api.response.PodResponse; |
| import com.cloud.api.response.PrivateGatewayResponse; |
| import com.cloud.api.response.ProjectAccountResponse; |
| import com.cloud.api.response.ProjectInvitationResponse; |
| import com.cloud.api.response.ProjectResponse; |
| import com.cloud.api.response.ProviderResponse; |
| import com.cloud.api.response.RemoteAccessVpnResponse; |
| import com.cloud.api.response.ResourceCountResponse; |
| import com.cloud.api.response.ResourceLimitResponse; |
| import com.cloud.api.response.ResourceTagResponse; |
| import com.cloud.api.response.S3Response; |
| import com.cloud.api.response.SecurityGroupResponse; |
| import com.cloud.api.response.SecurityGroupResultObject; |
| import com.cloud.api.response.SecurityGroupRuleResponse; |
| import com.cloud.api.response.SecurityGroupRuleResultObject; |
| import com.cloud.api.response.ServiceOfferingResponse; |
| import com.cloud.api.response.ServiceResponse; |
| import com.cloud.api.response.Site2SiteCustomerGatewayResponse; |
| import com.cloud.api.response.Site2SiteVpnConnectionResponse; |
| import com.cloud.api.response.Site2SiteVpnGatewayResponse; |
| import com.cloud.api.response.SnapshotPolicyResponse; |
| import com.cloud.api.response.SnapshotResponse; |
| import com.cloud.api.response.StaticRouteResponse; |
| import com.cloud.api.response.StorageNetworkIpRangeResponse; |
| import com.cloud.api.response.StoragePoolResponse; |
| import com.cloud.api.response.SwiftResponse; |
| import com.cloud.api.response.SystemVmInstanceResponse; |
| import com.cloud.api.response.SystemVmResponse; |
| import com.cloud.api.response.TemplatePermissionsResponse; |
| import com.cloud.api.response.TemplateResponse; |
| import com.cloud.api.response.TrafficTypeResponse; |
| import com.cloud.api.response.UserResponse; |
| import com.cloud.api.response.UserVmResponse; |
| import com.cloud.api.response.VirtualRouterProviderResponse; |
| import com.cloud.api.response.VlanIpRangeResponse; |
| import com.cloud.api.response.VolumeResponse; |
| import com.cloud.api.response.VpcOfferingResponse; |
| import com.cloud.api.response.VpcResponse; |
| import com.cloud.api.response.VpnUsersResponse; |
| import com.cloud.api.response.ZoneResponse; |
| import com.cloud.async.AsyncJob; |
| import com.cloud.capacity.Capacity; |
| import com.cloud.capacity.CapacityVO; |
| import com.cloud.capacity.dao.CapacityDaoImpl.SummedCapacity; |
| import com.cloud.configuration.Configuration; |
| import com.cloud.configuration.Resource.ResourceOwnerType; |
| import com.cloud.configuration.Resource.ResourceType; |
| import com.cloud.configuration.ResourceCount; |
| 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.Pod; |
| import com.cloud.dc.StorageNetworkIpRange; |
| import com.cloud.dc.Vlan; |
| import com.cloud.dc.Vlan.VlanType; |
| import com.cloud.dc.VlanVO; |
| import com.cloud.domain.Domain; |
| import com.cloud.event.Event; |
| import com.cloud.host.Host; |
| import com.cloud.host.HostStats; |
| import com.cloud.host.HostVO; |
| import com.cloud.hypervisor.HypervisorCapabilities; |
| import com.cloud.network.IPAddressVO; |
| import com.cloud.network.IpAddress; |
| import com.cloud.network.Network; |
| import com.cloud.network.Network.Capability; |
| import com.cloud.network.Network.Provider; |
| import com.cloud.network.Network.Service; |
| import com.cloud.network.NetworkProfile; |
| import com.cloud.network.Networks.TrafficType; |
| import com.cloud.network.PhysicalNetwork; |
| import com.cloud.network.PhysicalNetworkServiceProvider; |
| import com.cloud.network.PhysicalNetworkTrafficType; |
| import com.cloud.network.RemoteAccessVpn; |
| import com.cloud.network.Site2SiteCustomerGateway; |
| import com.cloud.network.Site2SiteCustomerGatewayVO; |
| import com.cloud.network.Site2SiteVpnConnection; |
| import com.cloud.network.Site2SiteVpnGateway; |
| import com.cloud.network.Site2SiteVpnGatewayVO; |
| import com.cloud.network.VirtualRouterProvider; |
| import com.cloud.network.VpnUser; |
| import com.cloud.network.as.AutoScalePolicy; |
| import com.cloud.network.as.AutoScaleVmGroup; |
| import com.cloud.network.as.AutoScaleVmProfile; |
| import com.cloud.network.as.Condition; |
| import com.cloud.network.as.ConditionVO; |
| import com.cloud.network.as.Counter; |
| import com.cloud.network.router.VirtualRouter; |
| import com.cloud.network.rules.FirewallRule; |
| import com.cloud.network.rules.LoadBalancer; |
| import com.cloud.network.rules.PortForwardingRule; |
| import com.cloud.network.rules.StaticNatRule; |
| import com.cloud.network.rules.StickinessPolicy; |
| import com.cloud.network.security.SecurityGroup; |
| import com.cloud.network.security.SecurityGroupRules; |
| import com.cloud.network.security.SecurityGroupVO; |
| import com.cloud.network.security.SecurityRule; |
| import com.cloud.network.security.SecurityRule.SecurityRuleType; |
| import com.cloud.network.vpc.PrivateGateway; |
| import com.cloud.network.vpc.StaticRoute; |
| import com.cloud.network.vpc.Vpc; |
| import com.cloud.network.vpc.VpcOffering; |
| import com.cloud.offering.DiskOffering; |
| import com.cloud.offering.NetworkOffering; |
| import com.cloud.offering.ServiceOffering; |
| import com.cloud.org.Cluster; |
| import com.cloud.projects.Project; |
| import com.cloud.projects.ProjectAccount; |
| import com.cloud.projects.ProjectInvitation; |
| import com.cloud.server.Criteria; |
| import com.cloud.server.ResourceTag; |
| import com.cloud.server.ResourceTag.TaggedResourceType; |
| import com.cloud.storage.DiskOfferingVO; |
| import com.cloud.storage.GuestOS; |
| import com.cloud.storage.GuestOSCategoryVO; |
| import com.cloud.storage.S3; |
| import com.cloud.storage.Snapshot; |
| import com.cloud.storage.Storage; |
| import com.cloud.storage.Storage.ImageFormat; |
| import com.cloud.storage.Storage.StoragePoolType; |
| import com.cloud.storage.Storage.TemplateType; |
| import com.cloud.storage.StoragePool; |
| import com.cloud.storage.StoragePoolVO; |
| import com.cloud.storage.StorageStats; |
| import com.cloud.storage.Swift; |
| import com.cloud.storage.UploadVO; |
| import com.cloud.storage.VMTemplateHostVO; |
| import com.cloud.storage.VMTemplateS3VO; |
| import com.cloud.storage.VMTemplateStorageResourceAssoc.Status; |
| import com.cloud.storage.VMTemplateSwiftVO; |
| import com.cloud.storage.VMTemplateVO; |
| import com.cloud.storage.Volume; |
| import com.cloud.storage.VolumeVO; |
| import com.cloud.storage.snapshot.SnapshotPolicy; |
| import com.cloud.template.VirtualMachineTemplate; |
| import com.cloud.test.PodZoneConfig; |
| import com.cloud.user.Account; |
| import com.cloud.user.User; |
| import com.cloud.user.UserAccount; |
| import com.cloud.user.UserContext; |
| import com.cloud.user.UserStatisticsVO; |
| import com.cloud.user.UserVO; |
| import com.cloud.uservm.UserVm; |
| import com.cloud.utils.Pair; |
| import com.cloud.utils.StringUtils; |
| import com.cloud.utils.net.NetUtils; |
| import com.cloud.vm.ConsoleProxyVO; |
| import com.cloud.vm.InstanceGroup; |
| import com.cloud.vm.InstanceGroupVO; |
| import com.cloud.vm.NicProfile; |
| import com.cloud.vm.UserVmDetailVO; |
| import com.cloud.vm.VMInstanceVO; |
| import com.cloud.vm.VirtualMachine; |
| import com.cloud.vm.VirtualMachine.State; |
| import com.cloud.vm.VirtualMachine.Type; |
| import com.cloud.vm.VmStats; |
| import com.cloud.vm.dao.UserVmData; |
| import com.cloud.vm.dao.UserVmData.NicData; |
| import com.cloud.vm.dao.UserVmData.SecurityGroupData; |
| |
| public class ApiResponseHelper implements ResponseGenerator { |
| |
| public final Logger s_logger = Logger.getLogger(ApiResponseHelper.class); |
| private static final DecimalFormat s_percentFormat = new DecimalFormat("##.##"); |
| |
| @Override |
| public UserResponse createUserResponse(User user) { |
| UserResponse userResponse = new UserResponse(); |
| Account account = ApiDBUtils.findAccountById(user.getAccountId()); |
| userResponse.setAccountName(account.getAccountName()); |
| userResponse.setAccountType(account.getType()); |
| userResponse.setCreated(user.getCreated()); |
| userResponse.setDomainId(account.getDomainId()); |
| userResponse.setDomainName(ApiDBUtils.findDomainById(account.getDomainId()).getName()); |
| userResponse.setEmail(user.getEmail()); |
| userResponse.setFirstname(user.getFirstname()); |
| userResponse.setId(user.getId()); |
| userResponse.setLastname(user.getLastname()); |
| userResponse.setState(user.getState().toString()); |
| userResponse.setTimezone(user.getTimezone()); |
| userResponse.setUsername(user.getUsername()); |
| userResponse.setApiKey(user.getApiKey()); |
| userResponse.setSecretKey(user.getSecretKey()); |
| userResponse.setObjectName("user"); |
| |
| return userResponse; |
| } |
| |
| // this method is used for response generation via createAccount (which creates an account + user) |
| @Override |
| public AccountResponse createUserAccountResponse(UserAccount user) { |
| return createAccountResponse(ApiDBUtils.findAccountById(user.getAccountId())); |
| } |
| |
| @Override |
| public 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().toString()); |
| accountResponse.setNetworkDomain(account.getNetworkDomain()); |
| accountResponse.setDefaultZone(account.getDefaultZoneId()); |
| |
| // 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 = 0L; |
| Long bytesReceived = 0L; |
| 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()); |
| |
| Long ips = ipLimit - ipTotal; |
| // check how many free ips are left, and if it's less than max allowed number of ips from account - use this |
| // value |
| Long ipsLeft = ApiDBUtils.countFreePublicIps(); |
| boolean unlimited = true; |
| if (ips.longValue() > ipsLeft.longValue()) { |
| ips = ipsLeft; |
| unlimited = false; |
| } |
| |
| String ipAvail = ((accountIsAdmin || ipLimit == -1) && unlimited) ? "Unlimited" : String.valueOf(ips); |
| |
| 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; |
| |
| List<Long> permittedAccounts = new ArrayList<Long>(); |
| permittedAccounts.add(account.getId()); |
| |
| List<? extends UserVm> virtualMachines = ApiDBUtils.searchForUserVMs(new Criteria(), permittedAccounts); |
| |
| // 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"); |
| |
| //get resource limits for projects |
| Long projectLimit = ApiDBUtils.findCorrectResourceLimit(ResourceType.project, account.getId()); |
| String projectLimitDisplay = (accountIsAdmin || projectLimit == -1) ? "Unlimited" : String.valueOf(projectLimit); |
| Long projectTotal = ApiDBUtils.getResourceCount(ResourceType.project, account.getId()); |
| String projectAvail = (accountIsAdmin || projectLimit == -1) ? "Unlimited" : String.valueOf(projectLimit - projectTotal); |
| accountResponse.setProjectLimit(projectLimitDisplay); |
| accountResponse.setProjectTotal(projectTotal); |
| accountResponse.setProjectAvailable(projectAvail); |
| |
| //get resource limits for networks |
| Long networkLimit = ApiDBUtils.findCorrectResourceLimit(ResourceType.network, account.getId()); |
| String networkLimitDisplay = (accountIsAdmin || networkLimit == -1) ? "Unlimited" : String.valueOf(networkLimit); |
| Long networkTotal = ApiDBUtils.getResourceCount(ResourceType.network, account.getId()); |
| String networkAvail = (accountIsAdmin || networkLimit == -1) ? "Unlimited" : String.valueOf(networkLimit - networkTotal); |
| accountResponse.setNetworkLimit(networkLimitDisplay); |
| accountResponse.setNetworkTotal(networkTotal); |
| accountResponse.setNetworkAvailable(networkAvail); |
| |
| //get resource limits for vpcs |
| Long vpcLimit = ApiDBUtils.findCorrectResourceLimit(ResourceType.vpc, account.getId()); |
| String vpcLimitDisplay = (accountIsAdmin || vpcLimit == -1) ? "Unlimited" : String.valueOf(vpcLimit); |
| Long vpcTotal = ApiDBUtils.getResourceCount(ResourceType.vpc, account.getId()); |
| String vpcAvail = (accountIsAdmin || vpcLimit == -1) ? "Unlimited" : String.valueOf(vpcLimit - vpcTotal); |
| accountResponse.setNetworkLimit(vpcLimitDisplay); |
| accountResponse.setNetworkTotal(vpcTotal); |
| accountResponse.setNetworkAvailable(vpcAvail); |
| |
| // adding all the users for an account as part of the response obj |
| List<UserVO> usersForAccount = ApiDBUtils.listUsersByAccount(account.getAccountId()); |
| List<UserResponse> userResponseList = new ArrayList<UserResponse>(); |
| for (UserVO user : usersForAccount) { |
| UserResponse userResponse = createUserResponse(user); |
| userResponseList.add(userResponse); |
| } |
| |
| accountResponse.setUsers(userResponseList); |
| accountResponse.setDetails(ApiDBUtils.getAccountDetails(account.getId())); |
| return accountResponse; |
| } |
| |
| |
| @Override |
| public UserResponse createUserResponse(UserAccount user) { |
| Account account = UserContext.current().getCaller(); |
| 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.setAccountId((user.getAccountId())); |
| userResponse.setIsCallerChildDomain(ApiDBUtils.isChildDomain(account.getDomainId(), user.getDomainId())); |
| userResponse.setObjectName("user"); |
| return userResponse; |
| } |
| |
| @Override |
| public DomainResponse createDomainResponse(Domain domain) { |
| DomainResponse domainResponse = new DomainResponse(); |
| domainResponse.setDomainName(domain.getName()); |
| domainResponse.setId(domain.getId()); |
| domainResponse.setLevel(domain.getLevel()); |
| domainResponse.setNetworkDomain(domain.getNetworkDomain()); |
| domainResponse.setParentDomainId(domain.getParent()); |
| StringBuilder domainPath = new StringBuilder("ROOT"); |
| (domainPath.append(domain.getPath())).deleteCharAt(domainPath.length() - 1); |
| domainResponse.setPath(domainPath.toString()); |
| if (domain.getParent() != null) { |
| domainResponse.setParentDomainName(ApiDBUtils.findDomainById(domain.getParent()).getName()); |
| } |
| if (domain.getChildCount() > 0) { |
| domainResponse.setHasChild(true); |
| } |
| domainResponse.setObjectName("domain"); |
| return domainResponse; |
| } |
| |
| @Override |
| public DiskOfferingResponse createDiskOfferingResponse(DiskOffering 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() / (1024 * 1024 * 1024)); |
| if (offering.getDomainId() != null) { |
| diskOfferingResponse.setDomain(ApiDBUtils.findDomainById(offering.getDomainId()).getName()); |
| diskOfferingResponse.setDomainId(offering.getDomainId()); |
| } |
| diskOfferingResponse.setTags(offering.getTags()); |
| diskOfferingResponse.setCustomized(offering.isCustomized()); |
| diskOfferingResponse.setStorageType(offering.getUseLocalStorage() ? ServiceOffering.StorageType.local.toString() : ServiceOffering.StorageType.shared.toString()); |
| diskOfferingResponse.setObjectName("diskoffering"); |
| return diskOfferingResponse; |
| } |
| |
| @Override |
| public ResourceLimitResponse createResourceLimitResponse(ResourceLimit limit) { |
| ResourceLimitResponse resourceLimitResponse = new ResourceLimitResponse(); |
| if (limit.getResourceOwnerType() == ResourceOwnerType.Domain) { |
| populateDomain(resourceLimitResponse, limit.getOwnerId()); |
| } else if (limit.getResourceOwnerType() == ResourceOwnerType.Account) { |
| Account accountTemp = ApiDBUtils.findAccountById(limit.getOwnerId()); |
| populateAccount(resourceLimitResponse, limit.getOwnerId()); |
| populateDomain(resourceLimitResponse, accountTemp.getDomainId()); |
| } |
| resourceLimitResponse.setResourceType(Integer.valueOf(limit.getType().getOrdinal()).toString()); |
| resourceLimitResponse.setMax(limit.getMax()); |
| resourceLimitResponse.setObjectName("resourcelimit"); |
| |
| return resourceLimitResponse; |
| } |
| |
| @Override |
| public ResourceCountResponse createResourceCountResponse(ResourceCount resourceCount) { |
| ResourceCountResponse resourceCountResponse = new ResourceCountResponse(); |
| |
| if (resourceCount.getResourceOwnerType() == ResourceOwnerType.Account) { |
| Account accountTemp = ApiDBUtils.findAccountById(resourceCount.getOwnerId()); |
| if (accountTemp != null) { |
| populateAccount(resourceCountResponse, accountTemp.getId()); |
| populateDomain(resourceCountResponse, accountTemp.getDomainId()); |
| } |
| } else if (resourceCount.getResourceOwnerType() == ResourceOwnerType.Domain) { |
| populateDomain(resourceCountResponse, resourceCount.getOwnerId()); |
| } |
| |
| resourceCountResponse.setResourceType(Integer.valueOf(resourceCount.getType().getOrdinal()).toString()); |
| resourceCountResponse.setResourceCount(resourceCount.getCount()); |
| resourceCountResponse.setObjectName("resourcecount"); |
| return resourceCountResponse; |
| } |
| |
| @Override |
| public ServiceOfferingResponse createServiceOfferingResponse(ServiceOffering offering) { |
| ServiceOfferingResponse offeringResponse = new ServiceOfferingResponse(); |
| offeringResponse.setId(offering.getId()); |
| offeringResponse.setName(offering.getName()); |
| offeringResponse.setIsSystemOffering(offering.getSystemUse()); |
| offeringResponse.setDefaultUse(offering.getDefaultUse()); |
| offeringResponse.setSystemVmType(offering.getSystemVmType()); |
| offeringResponse.setDisplayText(offering.getDisplayText()); |
| offeringResponse.setCpuNumber(offering.getCpu()); |
| offeringResponse.setCpuSpeed(offering.getSpeed()); |
| offeringResponse.setMemory(offering.getRamSize()); |
| offeringResponse.setCreated(offering.getCreated()); |
| offeringResponse.setStorageType(offering.getUseLocalStorage() ? ServiceOffering.StorageType.local.toString() : ServiceOffering.StorageType.shared.toString()); |
| offeringResponse.setOfferHa(offering.getOfferHA()); |
| offeringResponse.setLimitCpuUse(offering.getLimitCpuUse()); |
| offeringResponse.setTags(offering.getTags()); |
| if (offering.getDomainId() != null) { |
| offeringResponse.setDomain(ApiDBUtils.findDomainById(offering.getDomainId()).getName()); |
| offeringResponse.setDomainId(offering.getDomainId()); |
| } |
| offeringResponse.setNetworkRate(offering.getRateMbps()); |
| offeringResponse.setHostTag(offering.getHostTag()); |
| offeringResponse.setObjectName("serviceoffering"); |
| |
| return offeringResponse; |
| } |
| |
| @Override |
| public ConfigurationResponse createConfigurationResponse(Configuration 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; |
| } |
| |
| @Override |
| public SnapshotResponse createSnapshotResponse(Snapshot snapshot) { |
| SnapshotResponse snapshotResponse = new SnapshotResponse(); |
| snapshotResponse.setId(snapshot.getId()); |
| |
| populateOwner(snapshotResponse, snapshot); |
| |
| VolumeVO volume = findVolumeById(snapshot.getVolumeId()); |
| String snapshotTypeStr = snapshot.getType().name(); |
| snapshotResponse.setSnapshotType(snapshotTypeStr); |
| snapshotResponse.setVolumeId(snapshot.getVolumeId()); |
| if (volume != null) { |
| snapshotResponse.setVolumeName(volume.getName()); |
| snapshotResponse.setVolumeType(volume.getVolumeType().name()); |
| } |
| snapshotResponse.setCreated(snapshot.getCreated()); |
| snapshotResponse.setName(snapshot.getName()); |
| snapshotResponse.setIntervalType(ApiDBUtils.getSnapshotIntervalTypes(snapshot.getId())); |
| snapshotResponse.setState(snapshot.getStatus()); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.Snapshot, snapshot.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| snapshotResponse.setTags(tagResponses); |
| |
| snapshotResponse.setObjectName("snapshot"); |
| return snapshotResponse; |
| } |
| |
| @Override |
| public SnapshotPolicyResponse createSnapshotPolicyResponse(SnapshotPolicy 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; |
| } |
| |
| @Override |
| public HostResponse createHostResponse(Host host) { |
| return createHostResponse(host, EnumSet.of(HostDetails.all)); |
| } |
| |
| @Override |
| public HostResponse createHostResponse(Host host, EnumSet<HostDetails> details) { |
| 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()); |
| |
| if (details.contains(HostDetails.all) || details.contains(HostDetails.capacity) |
| || details.contains(HostDetails.stats) || details.contains(HostDetails.events)) { |
| |
| 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) { |
| HostPodVO pod = ApiDBUtils.findPodById(host.getPodId()); |
| if (pod != null) { |
| hostResponse.setPodName(pod.getName()); |
| } |
| } |
| |
| if (host.getClusterId() != null) { |
| ClusterVO cluster = ApiDBUtils.findClusterById(host.getClusterId()); |
| hostResponse.setClusterName(cluster.getName()); |
| hostResponse.setClusterType(cluster.getClusterType().toString()); |
| } |
| } |
| |
| DecimalFormat decimalFormat = new DecimalFormat("#.##"); |
| if (host.getType() == Host.Type.Routing) { |
| if (details.contains(HostDetails.all) || details.contains(HostDetails.capacity)) { |
| // set allocated capacities |
| Long mem = ApiDBUtils.getMemoryOrCpuCapacitybyHost(host.getId(), Capacity.CAPACITY_TYPE_MEMORY); |
| Long cpu = ApiDBUtils.getMemoryOrCpuCapacitybyHost(host.getId(), Capacity.CAPACITY_TYPE_CPU); |
| |
| hostResponse.setMemoryAllocated(mem); |
| hostResponse.setMemoryTotal(host.getTotalMemory()); |
| String hostTags = ApiDBUtils.getHostTags(host.getId()); |
| hostResponse.setHostTags(hostTags); |
| |
| String haTag = ApiDBUtils.getHaTag(); |
| if (haTag != null && !haTag.isEmpty() && hostTags != null && !hostTags.isEmpty()) { |
| if (haTag.equalsIgnoreCase(hostTags)) { |
| hostResponse.setHaHost(true); |
| } else { |
| hostResponse.setHaHost(false); |
| } |
| } else { |
| hostResponse.setHaHost(false); |
| } |
| |
| hostResponse.setHypervisorVersion(host.getHypervisorVersion()); |
| |
| String cpuAlloc = decimalFormat.format(((float) cpu / (float) (host.getCpus() * host.getSpeed())) * 100f) + "%"; |
| hostResponse.setCpuAllocated(cpuAlloc); |
| String cpuWithOverprovisioning = new Float(host.getCpus() * host.getSpeed() * ApiDBUtils.getCpuOverprovisioningFactor()).toString(); |
| hostResponse.setCpuWithOverprovisioning(cpuWithOverprovisioning); |
| } |
| |
| if (details.contains(HostDetails.all) || details.contains(HostDetails.stats)) { |
| // set CPU/RAM/Network stats |
| 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.setMemoryUsed((new Double(hostStats.getUsedMemory())).longValue()); |
| hostResponse.setNetworkKbsRead((new Double(hostStats.getNetworkReadKBs())).longValue()); |
| hostResponse.setNetworkKbsWrite((new Double(hostStats.getNetworkWriteKBs())).longValue()); |
| |
| } |
| } |
| |
| } else if (host.getType() == Host.Type.SecondaryStorage) { |
| StorageStats secStorageStats = ApiDBUtils.getSecondaryStorageStatistics(host.getId()); |
| if (secStorageStats != null) { |
| hostResponse.setDiskSizeTotal(secStorageStats.getCapacityBytes()); |
| hostResponse.setDiskSizeAllocated(secStorageStats.getByteUsed()); |
| } |
| } |
| |
| hostResponse.setLocalStorageActive(ApiDBUtils.isLocalStorageActiveOnHost(host)); |
| |
| if (details.contains(HostDetails.all) || details.contains(HostDetails.events)) { |
| Set<com.cloud.host.Status.Event> possibleEvents = host.getStatus().getPossibleEvents(); |
| if ((possibleEvents != null) && !possibleEvents.isEmpty()) { |
| String events = ""; |
| Iterator<com.cloud.host.Status.Event> iter = possibleEvents.iterator(); |
| while (iter.hasNext()) { |
| com.cloud.host.Status.Event event = iter.next(); |
| events += event.toString(); |
| if (iter.hasNext()) { |
| events += "; "; |
| } |
| } |
| hostResponse.setEvents(events); |
| } |
| } |
| |
| hostResponse.setResourceState(host.getResourceState().toString()); |
| hostResponse.setObjectName("host"); |
| |
| return hostResponse; |
| } |
| |
| @Override |
| public SwiftResponse createSwiftResponse(Swift swift) { |
| SwiftResponse swiftResponse = new SwiftResponse(); |
| swiftResponse.setId(swift.getId()); |
| swiftResponse.setUrl(swift.getUrl()); |
| swiftResponse.setAccount(swift.getAccount()); |
| swiftResponse.setUsername(swift.getUserName()); |
| swiftResponse.setObjectName("swift"); |
| return swiftResponse; |
| } |
| |
| @Override |
| public S3Response createS3Response(final S3 result) { |
| |
| final S3Response response = new S3Response(); |
| |
| response.setAccessKey(result.getAccessKey()); |
| response.setConnectionTimeout(result.getConnectionTimeout()); |
| response.setEndPoint(result.getEndPoint()); |
| response.setHttpsFlag(result.getHttpsFlag()); |
| response.setMaxErrorRetry(result.getMaxErrorRetry()); |
| response.setObjectId(result.getId()); |
| response.setSecretKey(result.getSecretKey()); |
| response.setSocketTimeout(result.getSocketTimeout()); |
| response.setTemplateBucketName(result.getBucketName()); |
| |
| return response; |
| |
| } |
| |
| @Override |
| public VlanIpRangeResponse createVlanIpRangeResponse(Vlan vlan) { |
| Long podId = ApiDBUtils.getPodIdForVlan(vlan.getId()); |
| |
| VlanIpRangeResponse vlanResponse = new VlanIpRangeResponse(); |
| vlanResponse.setId(vlan.getId()); |
| vlanResponse.setForVirtualNetwork(vlan.getVlanType().equals(VlanType.VirtualNetwork)); |
| vlanResponse.setVlan(vlan.getVlanTag()); |
| vlanResponse.setZoneId(vlan.getDataCenterId()); |
| |
| if (podId != null) { |
| HostPodVO pod = ApiDBUtils.findPodById(podId); |
| vlanResponse.setPodId(podId); |
| if (pod != null) { |
| vlanResponse.setPodName(pod.getName()); |
| } |
| } |
| |
| vlanResponse.setGateway(vlan.getVlanGateway()); |
| vlanResponse.setNetmask(vlan.getVlanNetmask()); |
| |
| // get start ip and end ip of corresponding vlan |
| String ipRange = vlan.getIpRange(); |
| if (ipRange != null) { |
| String[] range = ipRange.split("-"); |
| vlanResponse.setStartIp(range[0]); |
| vlanResponse.setEndIp(range[1]); |
| } |
| |
| vlanResponse.setIp6Gateway(vlan.getIp6Gateway()); |
| vlanResponse.setIp6Cidr(vlan.getIp6Cidr()); |
| |
| String ip6Range = vlan.getIp6Range(); |
| if (ip6Range != null) { |
| String[] range = ip6Range.split("-"); |
| vlanResponse.setStartIpv6(range[0]); |
| vlanResponse.setEndIpv6(range[1]); |
| } |
| |
| vlanResponse.setNetworkId(vlan.getNetworkId()); |
| Account owner = ApiDBUtils.getVlanAccount(vlan.getId()); |
| if (owner != null) { |
| populateAccount(vlanResponse, owner.getId()); |
| populateDomain(vlanResponse, owner.getDomainId()); |
| } |
| |
| vlanResponse.setPhysicalNetworkId(vlan.getPhysicalNetworkId()); |
| |
| vlanResponse.setObjectName("vlan"); |
| return vlanResponse; |
| } |
| |
| @Override |
| public IPAddressResponse createIPAddressResponse(IpAddress ipAddr) { |
| VlanVO vlan = ApiDBUtils.findVlanById(ipAddr.getVlanId()); |
| boolean forVirtualNetworks = vlan.getVlanType().equals(VlanType.VirtualNetwork); |
| long zoneId = ipAddr.getDataCenterId(); |
| |
| IPAddressResponse ipResponse = new IPAddressResponse(); |
| ipResponse.setId(ipAddr.getId()); |
| ipResponse.setIpAddress(ipAddr.getAddress().toString()); |
| if (ipAddr.getAllocatedTime() != null) { |
| ipResponse.setAllocated(ipAddr.getAllocatedTime()); |
| } |
| ipResponse.setZoneId(zoneId); |
| ipResponse.setZoneName(ApiDBUtils.findZoneById(ipAddr.getDataCenterId()).getName()); |
| ipResponse.setSourceNat(ipAddr.isSourceNat()); |
| ipResponse.setIsSystem(ipAddr.getSystem()); |
| |
| // get account information |
| if (ipAddr.getAllocatedToAccountId() != null) { |
| populateOwner(ipResponse, ipAddr); |
| } |
| |
| ipResponse.setForVirtualNetwork(forVirtualNetworks); |
| ipResponse.setStaticNat(ipAddr.isOneToOneNat()); |
| |
| if (ipAddr.getAssociatedWithVmId() != null) { |
| UserVm vm = ApiDBUtils.findUserVmById(ipAddr.getAssociatedWithVmId()); |
| ipResponse.setVirtualMachineId(vm.getId()); |
| ipResponse.setVirtualMachineName(vm.getHostName()); |
| if (vm.getDisplayName() != null) { |
| ipResponse.setVirtualMachineDisplayName(vm.getDisplayName()); |
| } else { |
| ipResponse.setVirtualMachineDisplayName(vm.getHostName()); |
| } |
| } |
| |
| if (ipAddr.getAssociatedWithNetworkId() != null) { |
| Network ntwk = ApiDBUtils.findNetworkById(ipAddr.getAssociatedWithNetworkId()); |
| ipResponse.setAssociatedNetworkId(ipAddr.getAssociatedWithNetworkId()); |
| ipResponse.setAssociatedNetworkName(ntwk.getName()); |
| } |
| |
| ipResponse.setVpcId(ipAddr.getVpcId()); |
| |
| // Network id the ip is associated with (if associated networkId is null, try to get this information from vlan) |
| Long vlanNetworkId = ApiDBUtils.getVlanNetworkId(ipAddr.getVlanId()); |
| |
| // Network id the ip belongs to |
| Long networkId; |
| if (vlanNetworkId != null) { |
| networkId = vlanNetworkId; |
| } else { |
| networkId = ApiDBUtils.getPublicNetworkIdByZone(zoneId); |
| } |
| |
| ipResponse.setNetworkId(networkId); |
| ipResponse.setState(ipAddr.getState().toString()); |
| ipResponse.setPhysicalNetworkId(ipAddr.getPhysicalNetworkId()); |
| |
| // show this info to admin only |
| Account account = UserContext.current().getCaller(); |
| if (account.getType() == Account.ACCOUNT_TYPE_ADMIN) { |
| ipResponse.setVlanId(ipAddr.getVlanId()); |
| ipResponse.setVlanName(ApiDBUtils.findVlanById(ipAddr.getVlanId()).getVlanTag()); |
| } |
| |
| if (ipAddr.getSystem()) { |
| if (ipAddr.isOneToOneNat()) { |
| ipResponse.setPurpose(IpAddress.Purpose.StaticNat.toString()); |
| } else { |
| ipResponse.setPurpose(IpAddress.Purpose.Lb.toString()); |
| } |
| } |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.PublicIpAddress, ipAddr.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| ipResponse.setTags(tagResponses); |
| |
| ipResponse.setObjectName("ipaddress"); |
| return ipResponse; |
| } |
| |
| @Override |
| public LoadBalancerResponse createLoadBalancerResponse(LoadBalancer loadBalancer) { |
| LoadBalancerResponse lbResponse = new LoadBalancerResponse(); |
| lbResponse.setId(loadBalancer.getId()); |
| lbResponse.setName(loadBalancer.getName()); |
| lbResponse.setDescription(loadBalancer.getDescription()); |
| List<String> cidrs = ApiDBUtils.findFirewallSourceCidrs(loadBalancer.getId()); |
| lbResponse.setCidrList(StringUtils.join(cidrs, ",")); |
| |
| IPAddressVO publicIp = ApiDBUtils.findIpAddressById(loadBalancer.getSourceIpAddressId()); |
| lbResponse.setPublicIpId(publicIp.getId()); |
| lbResponse.setPublicIp(publicIp.getAddress().addr()); |
| lbResponse.setPublicPort(Integer.toString(loadBalancer.getSourcePortStart())); |
| lbResponse.setPrivatePort(Integer.toString(loadBalancer.getDefaultPortStart())); |
| lbResponse.setAlgorithm(loadBalancer.getAlgorithm()); |
| FirewallRule.State state = loadBalancer.getState(); |
| String stateToSet = state.toString(); |
| if (state.equals(FirewallRule.State.Revoke)) { |
| stateToSet = "Deleting"; |
| } |
| lbResponse.setState(stateToSet); |
| populateOwner(lbResponse, loadBalancer); |
| lbResponse.setZoneId(publicIp.getDataCenterId()); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.UserVm, loadBalancer.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| lbResponse.setTags(tagResponses); |
| |
| lbResponse.setObjectName("loadbalancer"); |
| return lbResponse; |
| } |
| |
| @Override |
| public PodResponse createPodResponse(Pod pod, Boolean showCapacities) { |
| 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.setNetmask(NetUtils.getCidrNetmask(pod.getCidrSize())); |
| podResponse.setStartIp(ipRange[0]); |
| podResponse.setEndIp(((ipRange.length > 1) && (ipRange[1] != null)) ? ipRange[1] : ""); |
| podResponse.setGateway(pod.getGateway()); |
| podResponse.setAllocationState(pod.getAllocationState().toString()); |
| if (showCapacities != null && showCapacities) { |
| List<SummedCapacity> capacities = ApiDBUtils.getCapacityByClusterPodZone(null, pod.getId(), null); |
| Set<CapacityResponse> capacityResponses = new HashSet<CapacityResponse>(); |
| float cpuOverprovisioningFactor = ApiDBUtils.getCpuOverprovisioningFactor(); |
| |
| for (SummedCapacity capacity : capacities) { |
| CapacityResponse capacityResponse = new CapacityResponse(); |
| capacityResponse.setCapacityType(capacity.getCapacityType()); |
| capacityResponse.setCapacityUsed(capacity.getUsedCapacity()); |
| if (capacity.getCapacityType() == Capacity.CAPACITY_TYPE_CPU) { |
| capacityResponse.setCapacityTotal(new Long((long) (capacity.getTotalCapacity() * cpuOverprovisioningFactor))); |
| } else if (capacity.getCapacityType() == Capacity.CAPACITY_TYPE_STORAGE_ALLOCATED) { |
| List<SummedCapacity> c = ApiDBUtils.findNonSharedStorageForClusterPodZone(null, pod.getId(), null); |
| capacityResponse.setCapacityTotal(capacity.getTotalCapacity() - c.get(0).getTotalCapacity()); |
| capacityResponse.setCapacityUsed(capacity.getUsedCapacity() - c.get(0).getUsedCapacity()); |
| } else { |
| capacityResponse.setCapacityTotal(capacity.getTotalCapacity()); |
| } |
| if (capacityResponse.getCapacityTotal() != 0) { |
| capacityResponse.setPercentUsed(s_percentFormat.format((float) capacityResponse.getCapacityUsed() / (float) capacityResponse.getCapacityTotal() * 100f)); |
| } else { |
| capacityResponse.setPercentUsed(s_percentFormat.format(0L)); |
| } |
| capacityResponses.add(capacityResponse); |
| } |
| // Do it for stats as well. |
| capacityResponses.addAll(getStatsCapacityresponse(null, null, pod.getId(), pod.getDataCenterId())); |
| podResponse.setCapacitites(new ArrayList<CapacityResponse>(capacityResponses)); |
| } |
| podResponse.setObjectName("pod"); |
| return podResponse; |
| } |
| |
| @Override |
| public ZoneResponse createZoneResponse(DataCenter dataCenter, Boolean showCapacities) { |
| Account account = UserContext.current().getCaller(); |
| ZoneResponse zoneResponse = new ZoneResponse(); |
| zoneResponse.setId(dataCenter.getId()); |
| zoneResponse.setName(dataCenter.getName()); |
| zoneResponse.setSecurityGroupsEnabled(ApiDBUtils.isSecurityGroupEnabledInZone(dataCenter.getId())); |
| zoneResponse.setLocalStorageEnabled(dataCenter.isLocalStorageEnabled()); |
| |
| 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()); |
| // FIXME zoneResponse.setVlan(dataCenter.get.getVnet()); |
| zoneResponse.setGuestCidrAddress(dataCenter.getGuestNetworkCidr()); |
| } |
| |
| if (showCapacities != null && showCapacities) { |
| List<SummedCapacity> capacities = ApiDBUtils.getCapacityByClusterPodZone(dataCenter.getId(), null, null); |
| Set<CapacityResponse> capacityResponses = new HashSet<CapacityResponse>(); |
| float cpuOverprovisioningFactor = ApiDBUtils.getCpuOverprovisioningFactor(); |
| |
| for (SummedCapacity capacity : capacities) { |
| CapacityResponse capacityResponse = new CapacityResponse(); |
| capacityResponse.setCapacityType(capacity.getCapacityType()); |
| capacityResponse.setCapacityUsed(capacity.getUsedCapacity()); |
| if (capacity.getCapacityType() == Capacity.CAPACITY_TYPE_CPU) { |
| capacityResponse.setCapacityTotal(new Long((long) (capacity.getTotalCapacity() * cpuOverprovisioningFactor))); |
| } else if (capacity.getCapacityType() == Capacity.CAPACITY_TYPE_STORAGE_ALLOCATED) { |
| List<SummedCapacity> c = ApiDBUtils.findNonSharedStorageForClusterPodZone(dataCenter.getId(), null, null); |
| capacityResponse.setCapacityTotal(capacity.getTotalCapacity() - c.get(0).getTotalCapacity()); |
| capacityResponse.setCapacityUsed(capacity.getUsedCapacity() - c.get(0).getUsedCapacity()); |
| } else { |
| capacityResponse.setCapacityTotal(capacity.getTotalCapacity()); |
| } |
| if (capacityResponse.getCapacityTotal() != 0) { |
| capacityResponse.setPercentUsed(s_percentFormat.format((float) capacityResponse.getCapacityUsed() / (float) capacityResponse.getCapacityTotal() * 100f)); |
| } else { |
| capacityResponse.setPercentUsed(s_percentFormat.format(0L)); |
| } |
| capacityResponses.add(capacityResponse); |
| } |
| // Do it for stats as well. |
| capacityResponses.addAll(getStatsCapacityresponse(null, null, null, dataCenter.getId())); |
| |
| zoneResponse.setCapacitites(new ArrayList<CapacityResponse>(capacityResponses)); |
| } |
| |
| // set network domain info |
| zoneResponse.setDomain(dataCenter.getDomain()); |
| |
| // set domain info |
| Long domainId = dataCenter.getDomainId(); |
| if (domainId != null) { |
| Domain domain = ApiDBUtils.findDomainById(domainId); |
| zoneResponse.setDomainId(domain.getId()); |
| zoneResponse.setDomainName(domain.getName()); |
| } |
| |
| zoneResponse.setType(dataCenter.getNetworkType().toString()); |
| zoneResponse.setAllocationState(dataCenter.getAllocationState().toString()); |
| zoneResponse.setZoneToken(dataCenter.getZoneToken()); |
| zoneResponse.setDhcpProvider(dataCenter.getDhcpProvider()); |
| zoneResponse.setObjectName("zone"); |
| return zoneResponse; |
| } |
| |
| private List<CapacityResponse> getStatsCapacityresponse(Long poolId, Long clusterId, Long podId, Long zoneId) { |
| List<CapacityVO> capacities = new ArrayList<CapacityVO>(); |
| capacities.add(ApiDBUtils.getStoragePoolUsedStats(poolId, clusterId, podId, zoneId)); |
| if (clusterId == null && podId == null) { |
| capacities.add(ApiDBUtils.getSecondaryStorageUsedStats(poolId, zoneId)); |
| } |
| |
| List<CapacityResponse> capacityResponses = new ArrayList<CapacityResponse>(); |
| for (CapacityVO capacity : capacities) { |
| CapacityResponse capacityResponse = new CapacityResponse(); |
| capacityResponse.setCapacityType(capacity.getCapacityType()); |
| capacityResponse.setCapacityUsed(capacity.getUsedCapacity()); |
| capacityResponse.setCapacityTotal(capacity.getTotalCapacity()); |
| if (capacityResponse.getCapacityTotal() != 0) { |
| capacityResponse.setPercentUsed(s_percentFormat.format((float) capacityResponse.getCapacityUsed() / (float) capacityResponse.getCapacityTotal() * 100f)); |
| } else { |
| capacityResponse.setPercentUsed(s_percentFormat.format(0L)); |
| } |
| capacityResponses.add(capacityResponse); |
| } |
| |
| return capacityResponses; |
| } |
| |
| @Override |
| public VolumeResponse createVolumeResponse(Volume volume) { |
| VolumeResponse volResponse = new VolumeResponse(); |
| volResponse.setId(volume.getId()); |
| |
| 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 && volume.getState() != Volume.State.Destroy) { |
| VMInstanceVO vm = ApiDBUtils.findVMInstanceById(instanceId); |
| if (vm != null) { |
| volResponse.setVirtualMachineId(vm.getId()); |
| volResponse.setVirtualMachineName(vm.getHostName()); |
| UserVm userVm = ApiDBUtils.findUserVmById(vm.getId()); |
| if (userVm != null) { |
| if (userVm.getDisplayName() != null) { |
| volResponse.setVirtualMachineDisplayName(userVm.getDisplayName()); |
| } else { |
| volResponse.setVirtualMachineDisplayName(userVm.getHostName()); |
| } |
| volResponse.setVirtualMachineState(vm.getState().toString()); |
| } else { |
| s_logger.error("User Vm with Id: " + instanceId + " does not exist for volume " + volume.getId()); |
| } |
| } else { |
| s_logger.error("Vm with Id: " + instanceId + " does not exist for volume " + volume.getId()); |
| } |
| } |
| |
| // Show the virtual size of the volume |
| volResponse.setSize(volume.getSize()); |
| |
| volResponse.setCreated(volume.getCreated()); |
| volResponse.setState(volume.getState().toString()); |
| if(volume.getState() == Volume.State.UploadOp){ |
| com.cloud.storage.VolumeHostVO volumeHostRef = ApiDBUtils.findVolumeHostRef(volume.getId(), volume.getDataCenterId()); |
| volResponse.setSize(volumeHostRef.getSize()); |
| volResponse.setCreated(volumeHostRef.getCreated()); |
| Account caller = UserContext.current().getCaller(); |
| if (caller.getType() == Account.ACCOUNT_TYPE_ADMIN || caller.getType() == Account.ACCOUNT_TYPE_RESOURCE_DOMAIN_ADMIN) |
| volResponse.setHypervisor(ApiDBUtils.getHypervisorTypeFromFormat(volumeHostRef.getFormat()).toString()); |
| if (volumeHostRef.getDownloadState() != Status.DOWNLOADED) { |
| String volumeStatus = "Processing"; |
| if (volumeHostRef.getDownloadState() == VMTemplateHostVO.Status.DOWNLOAD_IN_PROGRESS) { |
| if (volumeHostRef.getDownloadPercent() == 100) { |
| volumeStatus = "Checking Volume"; |
| } else { |
| volumeStatus = volumeHostRef.getDownloadPercent() + "% Uploaded"; |
| } |
| volResponse.setState("Uploading"); |
| } else { |
| volumeStatus = volumeHostRef.getErrorString(); |
| if(volumeHostRef.getDownloadState() == VMTemplateHostVO.Status.NOT_DOWNLOADED){ |
| volResponse.setState("UploadNotStarted"); |
| }else { |
| volResponse.setState("UploadError"); |
| } |
| } |
| volResponse.setStatus(volumeStatus); |
| } else if (volumeHostRef.getDownloadState() == VMTemplateHostVO.Status.DOWNLOADED) { |
| volResponse.setStatus("Upload Complete"); |
| volResponse.setState("Uploaded"); |
| } else { |
| volResponse.setStatus("Successfully Installed"); |
| } |
| } |
| |
| populateOwner(volResponse, volume); |
| |
| if (volume.getVolumeType().equals(Volume.Type.ROOT)) { |
| volResponse.setServiceOfferingId(volume.getDiskOfferingId()); |
| } else { |
| volResponse.setDiskOfferingId(volume.getDiskOfferingId()); |
| } |
| |
| DiskOfferingVO diskOffering = ApiDBUtils.findDiskOfferingById(volume.getDiskOfferingId()); |
| if (volume.getVolumeType().equals(Volume.Type.ROOT)) { |
| volResponse.setServiceOfferingName(diskOffering.getName()); |
| volResponse.setServiceOfferingDisplayText(diskOffering.getDisplayText()); |
| } else { |
| volResponse.setDiskOfferingName(diskOffering.getName()); |
| volResponse.setDiskOfferingDisplayText(diskOffering.getDisplayText()); |
| } |
| volResponse.setStorageType(diskOffering.getUseLocalStorage() ? ServiceOffering.StorageType.local.toString() : ServiceOffering.StorageType.shared.toString()); |
| |
| 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()); |
| // } |
| |
| // return hypervisor for ROOT and Resource domain only |
| Account caller = UserContext.current().getCaller(); |
| if ((caller.getType() == Account.ACCOUNT_TYPE_ADMIN || caller.getType() == Account.ACCOUNT_TYPE_RESOURCE_DOMAIN_ADMIN) && volume.getState() != Volume.State.UploadOp) { |
| volResponse.setHypervisor(ApiDBUtils.getVolumeHyperType(volume.getId()).toString()); |
| } |
| |
| volResponse.setAttached(volume.getAttached()); |
| volResponse.setDestroyed(volume.getState() == Volume.State.Destroy); |
| boolean isExtractable = true; |
| if (volume.getVolumeType() != Volume.Type.DATADISK) { // Datadisk dont have any template dependence. |
| VMTemplateVO template = ApiDBUtils.findTemplateById(volume.getTemplateId()); |
| if (template != null) { // For ISO based volumes template = null and we allow extraction of all ISO based volumes |
| isExtractable = template.isExtractable() && template.getTemplateType() != Storage.TemplateType.SYSTEM; |
| } |
| } |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.Volume, volume.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| volResponse.setTags(tagResponses); |
| |
| volResponse.setExtractable(isExtractable); |
| volResponse.setObjectName("volume"); |
| return volResponse; |
| } |
| |
| @Override |
| public InstanceGroupResponse createInstanceGroupResponse(InstanceGroup group) { |
| InstanceGroupResponse groupResponse = new InstanceGroupResponse(); |
| groupResponse.setId(group.getId()); |
| groupResponse.setName(group.getName()); |
| groupResponse.setCreated(group.getCreated()); |
| |
| populateOwner(groupResponse, group); |
| |
| groupResponse.setObjectName("instancegroup"); |
| return groupResponse; |
| } |
| |
| @Override |
| public StoragePoolResponse createStoragePoolResponse(StoragePool 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()); |
| HostPodVO pod = ApiDBUtils.findPodById(pool.getPodId()); |
| if (pod != null) { |
| poolResponse.setPodName(pod.getName()); |
| } |
| } |
| if (pool.getCreated() != null) { |
| poolResponse.setCreated(pool.getCreated()); |
| } |
| |
| StorageStats stats = ApiDBUtils.getStoragePoolStatistics(pool.getId()); |
| long allocatedSize = ApiDBUtils.getStorageCapacitybyPool(pool.getId(), Capacity.CAPACITY_TYPE_STORAGE_ALLOCATED); |
| poolResponse.setDiskSizeTotal(pool.getCapacityBytes()); |
| poolResponse.setDiskSizeAllocated(allocatedSize); |
| |
| if (stats != null) { |
| Long used = stats.getByteUsed(); |
| poolResponse.setDiskSizeUsed(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; |
| } |
| |
| @Override |
| public ClusterResponse createClusterResponse(Cluster cluster, Boolean showCapacities) { |
| ClusterResponse clusterResponse = new ClusterResponse(); |
| clusterResponse.setId(cluster.getId()); |
| clusterResponse.setName(cluster.getName()); |
| clusterResponse.setPodId(cluster.getPodId()); |
| clusterResponse.setZoneId(cluster.getDataCenterId()); |
| clusterResponse.setHypervisorType(cluster.getHypervisorType().toString()); |
| clusterResponse.setClusterType(cluster.getClusterType().toString()); |
| clusterResponse.setAllocationState(cluster.getAllocationState().toString()); |
| clusterResponse.setManagedState(cluster.getManagedState().toString()); |
| HostPodVO pod = ApiDBUtils.findPodById(cluster.getPodId()); |
| if (pod != null) { |
| clusterResponse.setPodName(pod.getName()); |
| } |
| DataCenterVO zone = ApiDBUtils.findZoneById(cluster.getDataCenterId()); |
| clusterResponse.setZoneName(zone.getName()); |
| if (showCapacities != null && showCapacities) { |
| List<SummedCapacity> capacities = ApiDBUtils.getCapacityByClusterPodZone(null, null, cluster.getId()); |
| Set<CapacityResponse> capacityResponses = new HashSet<CapacityResponse>(); |
| float cpuOverprovisioningFactor = ApiDBUtils.getCpuOverprovisioningFactor(); |
| |
| for (SummedCapacity capacity : capacities) { |
| CapacityResponse capacityResponse = new CapacityResponse(); |
| capacityResponse.setCapacityType(capacity.getCapacityType()); |
| capacityResponse.setCapacityUsed(capacity.getUsedCapacity()); |
| |
| if (capacity.getCapacityType() == Capacity.CAPACITY_TYPE_CPU) { |
| capacityResponse.setCapacityTotal(new Long((long) (capacity.getTotalCapacity() * cpuOverprovisioningFactor))); |
| } else if (capacity.getCapacityType() == Capacity.CAPACITY_TYPE_STORAGE_ALLOCATED) { |
| List<SummedCapacity> c = ApiDBUtils.findNonSharedStorageForClusterPodZone(null, null, cluster.getId()); |
| capacityResponse.setCapacityTotal(capacity.getTotalCapacity() - c.get(0).getTotalCapacity()); |
| capacityResponse.setCapacityUsed(capacity.getUsedCapacity() - c.get(0).getUsedCapacity()); |
| } else { |
| capacityResponse.setCapacityTotal(capacity.getTotalCapacity()); |
| } |
| if (capacityResponse.getCapacityTotal() != 0) { |
| capacityResponse.setPercentUsed(s_percentFormat.format((float) capacityResponse.getCapacityUsed() / (float) capacityResponse.getCapacityTotal() * 100f)); |
| } else { |
| capacityResponse.setPercentUsed(s_percentFormat.format(0L)); |
| } |
| capacityResponses.add(capacityResponse); |
| } |
| // Do it for stats as well. |
| capacityResponses.addAll(getStatsCapacityresponse(null, cluster.getId(), pod.getId(), pod.getDataCenterId())); |
| clusterResponse.setCapacitites(new ArrayList<CapacityResponse>(capacityResponses)); |
| } |
| clusterResponse.setObjectName("cluster"); |
| return clusterResponse; |
| } |
| |
| @Override |
| public FirewallRuleResponse createPortForwardingRuleResponse(PortForwardingRule fwRule) { |
| FirewallRuleResponse response = new FirewallRuleResponse(); |
| response.setId(fwRule.getId()); |
| response.setPrivateStartPort(Integer.toString(fwRule.getDestinationPortStart())); |
| response.setPrivateEndPort(Integer.toString(fwRule.getDestinationPortEnd())); |
| response.setProtocol(fwRule.getProtocol()); |
| response.setPublicStartPort(Integer.toString(fwRule.getSourcePortStart())); |
| response.setPublicEndPort(Integer.toString(fwRule.getSourcePortEnd())); |
| List<String> cidrs = ApiDBUtils.findFirewallSourceCidrs(fwRule.getId()); |
| response.setCidrList(StringUtils.join(cidrs, ",")); |
| |
| IpAddress ip = ApiDBUtils.findIpAddressById(fwRule.getSourceIpAddressId()); |
| response.setPublicIpAddressId(ip.getId()); |
| response.setPublicIpAddress(ip.getAddress().addr()); |
| |
| if (ip != null && fwRule.getDestinationIpAddress() != null) { |
| UserVm vm = ApiDBUtils.findUserVmById(fwRule.getVirtualMachineId()); |
| if (vm != null) { |
| response.setVirtualMachineId(vm.getId()); |
| response.setVirtualMachineName(vm.getHostName()); |
| |
| if (vm.getDisplayName() != null) { |
| response.setVirtualMachineDisplayName(vm.getDisplayName()); |
| } else { |
| response.setVirtualMachineDisplayName(vm.getHostName()); |
| } |
| } |
| } |
| FirewallRule.State state = fwRule.getState(); |
| String stateToSet = state.toString(); |
| if (state.equals(FirewallRule.State.Revoke)) { |
| stateToSet = "Deleting"; |
| } |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.PortForwardingRule, fwRule.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| response.setTags(tagResponses); |
| |
| response.setState(stateToSet); |
| response.setObjectName("portforwardingrule"); |
| return response; |
| } |
| |
| @Override |
| public IpForwardingRuleResponse createIpForwardingRuleResponse(StaticNatRule fwRule) { |
| IpForwardingRuleResponse response = new IpForwardingRuleResponse(); |
| response.setId(fwRule.getId()); |
| response.setProtocol(fwRule.getProtocol()); |
| |
| IpAddress ip = ApiDBUtils.findIpAddressById(fwRule.getSourceIpAddressId()); |
| response.setPublicIpAddressId(ip.getId()); |
| response.setPublicIpAddress(ip.getAddress().addr()); |
| |
| if (ip != null && fwRule.getDestIpAddress() != null) { |
| UserVm vm = ApiDBUtils.findUserVmById(ip.getAssociatedWithVmId()); |
| if (vm != null) {// vm might be destroyed |
| response.setVirtualMachineId(vm.getId()); |
| response.setVirtualMachineName(vm.getHostName()); |
| if (vm.getDisplayName() != null) { |
| response.setVirtualMachineDisplayName(vm.getDisplayName()); |
| } else { |
| response.setVirtualMachineDisplayName(vm.getHostName()); |
| } |
| } |
| } |
| FirewallRule.State state = fwRule.getState(); |
| String stateToSet = state.toString(); |
| if (state.equals(FirewallRule.State.Revoke)) { |
| stateToSet = "Deleting"; |
| } |
| |
| response.setStartPort(fwRule.getSourcePortStart()); |
| response.setEndPort(fwRule.getSourcePortEnd()); |
| response.setProtocol(fwRule.getProtocol()); |
| response.setState(stateToSet); |
| response.setObjectName("ipforwardingrule"); |
| return response; |
| } |
| |
| @Override |
| public List<UserVmResponse> createUserVmResponse(String objectName, EnumSet<VMDetails> details, UserVm... userVms) { |
| Account caller = UserContext.current().getCaller(); |
| Map<Long, DataCenter> dataCenters = new HashMap<Long, DataCenter>(); |
| Map<Long, Host> hosts = new HashMap<Long, Host>(); |
| Map<Long, VMTemplateVO> templates = new HashMap<Long, VMTemplateVO>(); |
| Map<Long, ServiceOffering> serviceOfferings = new HashMap<Long, ServiceOffering>(); |
| Map<Long, Network> networks = new HashMap<Long, Network>(); |
| |
| List<UserVmResponse> vmResponses = new ArrayList<UserVmResponse>(); |
| |
| for (UserVm userVm : userVms) { |
| UserVmResponse userVmResponse = new UserVmResponse(); |
| Account acct = ApiDBUtils.findAccountById(Long.valueOf(userVm.getAccountId())); |
| if (acct != null) { |
| userVmResponse.setAccountName(acct.getAccountName()); |
| userVmResponse.setDomainId(acct.getDomainId()); |
| userVmResponse.setDomainName(ApiDBUtils.findDomainById(acct.getDomainId()).getName()); |
| } |
| |
| userVmResponse.setId(userVm.getId()); |
| userVmResponse.setName(userVm.getHostName()); |
| userVmResponse.setCreated(userVm.getCreated()); |
| |
| userVmResponse.setHaEnable(userVm.isHaEnabled()); |
| |
| if (userVm.getDisplayName() != null) { |
| userVmResponse.setDisplayName(userVm.getDisplayName()); |
| } else { |
| userVmResponse.setDisplayName(userVm.getHostName()); |
| } |
| |
| if (caller.getType() == Account.ACCOUNT_TYPE_ADMIN) { |
| userVmResponse.setInstanceName(userVm.getInstanceName()); |
| } |
| |
| |
| if (userVm.getPassword() != null) { |
| userVmResponse.setPassword(userVm.getPassword()); |
| } |
| |
| if (details.contains(VMDetails.all) || details.contains(VMDetails.group)) { |
| InstanceGroupVO group = ApiDBUtils.findInstanceGroupForVM(userVm.getId()); |
| if (group != null) { |
| userVmResponse.setGroup(group.getName()); |
| userVmResponse.setGroupId(group.getId()); |
| } |
| |
| } |
| |
| // Data Center Info |
| DataCenter zone = dataCenters.get(userVm.getDataCenterIdToDeployIn()); |
| if (zone == null) { |
| zone = ApiDBUtils.findZoneById(userVm.getDataCenterIdToDeployIn()); |
| dataCenters.put(zone.getId(), zone); |
| } |
| |
| userVmResponse.setZoneId(zone.getId()); |
| userVmResponse.setZoneName(zone.getName()); |
| |
| // if user is an admin, display host id |
| if (((caller == null) || (caller.getType() == Account.ACCOUNT_TYPE_ADMIN)) && (userVm.getHostId() != null)) { |
| Host host = hosts.get(userVm.getHostId()); |
| |
| if (host == null) { |
| host = ApiDBUtils.findHostById(userVm.getHostId()); |
| hosts.put(host.getId(), host); |
| } |
| |
| userVmResponse.setHostId(host.getId()); |
| userVmResponse.setHostName(host.getName()); |
| } |
| |
| if (userVm.getState() != null) { |
| if (userVm.getHostId() != null) { |
| Host host = hosts.get(userVm.getHostId()); |
| |
| if (host == null) { |
| host = ApiDBUtils.findHostById(userVm.getHostId()); |
| hosts.put(host.getId(), host); |
| } |
| if (host.getStatus() != com.cloud.host.Status.Up) { |
| userVmResponse.setState(VirtualMachine.State.Unknown.toString()); |
| } else { |
| userVmResponse.setState(userVm.getState().toString()); |
| } |
| } else { |
| userVmResponse.setState(userVm.getState().toString()); |
| } |
| } |
| |
| if (userVm.getHypervisorType() != null) { |
| userVmResponse.setHypervisor(userVm.getHypervisorType().toString()); |
| } |
| |
| if (details.contains(VMDetails.all) || details.contains(VMDetails.tmpl)) { |
| // Template Info |
| VMTemplateVO template = templates.get(userVm.getTemplateId()); |
| if (template == null) { |
| template = ApiDBUtils.findTemplateById(userVm.getTemplateId()); |
| if (template != null) { |
| templates.put(template.getId(), template); |
| } |
| } |
| |
| 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 (details.contains(VMDetails.all) || details.contains(VMDetails.iso)) { |
| // ISO Info |
| VMTemplateVO iso = templates.get(userVm.getIsoId()); |
| if (iso == null) { |
| iso = ApiDBUtils.findTemplateById(userVm.getIsoId()); |
| if (iso != null) { |
| templates.put(iso.getId(), iso); |
| } |
| } |
| |
| if (iso != null) { |
| userVmResponse.setIsoId(iso.getId()); |
| userVmResponse.setIsoName(iso.getName()); |
| } |
| } |
| |
| if (details.contains(VMDetails.all) || details.contains(VMDetails.servoff)) { |
| // Service Offering Info |
| ServiceOffering offering = serviceOfferings.get(userVm.getServiceOfferingId()); |
| |
| if (offering == null) { |
| offering = ApiDBUtils.findServiceOfferingById(userVm.getServiceOfferingId()); |
| serviceOfferings.put(offering.getId(), offering); |
| } |
| |
| userVmResponse.setServiceOfferingId(offering.getId()); |
| userVmResponse.setServiceOfferingName(offering.getName()); |
| userVmResponse.setCpuNumber(offering.getCpu()); |
| userVmResponse.setCpuSpeed(offering.getSpeed()); |
| userVmResponse.setMemory(offering.getRamSize()); |
| } |
| |
| if (details.contains(VMDetails.all) || details.contains(VMDetails.volume)) { |
| 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); |
| } |
| } |
| |
| if (details.contains(VMDetails.all) || details.contains(VMDetails.stats)) { |
| // 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); |
| |
| Double networkKbRead = Double.valueOf(vmStats.getNetworkReadKBs()); |
| userVmResponse.setNetworkKbsRead(networkKbRead.longValue()); |
| |
| Double networkKbWrite = Double.valueOf(vmStats.getNetworkWriteKBs()); |
| userVmResponse.setNetworkKbsWrite(networkKbWrite.longValue()); |
| } |
| } |
| |
| userVmResponse.setGuestOsId(userVm.getGuestOSId()); |
| |
| if (details.contains(VMDetails.all) || details.contains(VMDetails.secgrp)) { |
| // security groups - list only when zone is security group enabled |
| if (zone.isSecurityGroupEnabled()) { |
| List<SecurityGroupVO> securityGroups = ApiDBUtils.getSecurityGroupsForVm(userVm.getId()); |
| List<SecurityGroupResponse> securityGroupResponse = new ArrayList<SecurityGroupResponse>(); |
| for (SecurityGroupVO grp : securityGroups) { |
| SecurityGroupResponse resp = new SecurityGroupResponse(); |
| resp.setId(grp.getId()); |
| resp.setName(grp.getName()); |
| resp.setDescription(grp.getDescription()); |
| resp.setObjectName("securitygroup"); |
| securityGroupResponse.add(resp); |
| } |
| userVmResponse.setSecurityGroupList(securityGroupResponse); |
| } |
| } |
| |
| if (details.contains(VMDetails.all) || details.contains(VMDetails.nics)) { |
| List<NicProfile> nicProfiles = ApiDBUtils.getNics(userVm); |
| List<NicResponse> nicResponses = new ArrayList<NicResponse>(); |
| for (NicProfile singleNicProfile : nicProfiles) { |
| NicResponse nicResponse = new NicResponse(); |
| nicResponse.setId(singleNicProfile.getId()); |
| nicResponse.setIpaddress(singleNicProfile.getIp4Address()); |
| nicResponse.setGateway(singleNicProfile.getGateway()); |
| nicResponse.setNetmask(singleNicProfile.getNetmask()); |
| nicResponse.setIp6Address(singleNicProfile.getIp6Address()); |
| nicResponse.setIp6Gateway(singleNicProfile.getIp6Gateway()); |
| nicResponse.setIp6Cidr(singleNicProfile.getIp6Cidr()); |
| nicResponse.setNetworkid(singleNicProfile.getNetworkId()); |
| nicResponse.setNetworkName(ApiDBUtils.findNetworkById(singleNicProfile.getNetworkId()).getName()); |
| if (acct.getType() == Account.ACCOUNT_TYPE_ADMIN) { |
| if (singleNicProfile.getBroadCastUri() != null) { |
| nicResponse.setBroadcastUri(singleNicProfile.getBroadCastUri().toString()); |
| } |
| if (singleNicProfile.getIsolationUri() != null) { |
| nicResponse.setIsolationUri(singleNicProfile.getIsolationUri().toString()); |
| } |
| } |
| |
| // Long networkId = singleNicProfile.getNetworkId(); |
| Network network = networks.get(singleNicProfile.getNetworkId()); |
| if (network == null) { |
| network = ApiDBUtils.findNetworkById(singleNicProfile.getNetworkId()); |
| networks.put(singleNicProfile.getNetworkId(), network); |
| } |
| |
| nicResponse.setTrafficType(network.getTrafficType().toString()); |
| nicResponse.setType(network.getGuestType().toString()); |
| nicResponse.setIsDefault(singleNicProfile.isDefaultNic()); |
| nicResponse.setObjectName("nic"); |
| nicResponses.add(nicResponse); |
| } |
| userVmResponse.setNics(nicResponses); |
| } |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.UserVm, userVm.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| userVmResponse.setTags(tagResponses); |
| |
| IpAddress ip = ApiDBUtils.findIpByAssociatedVmId(userVm.getId()); |
| if (ip != null) { |
| userVmResponse.setPublicIpId(ip.getId()); |
| userVmResponse.setPublicIp(ip.getAddress().addr()); |
| } |
| |
| userVmResponse.setObjectName(objectName); |
| vmResponses.add(userVmResponse); |
| } |
| |
| return vmResponses; |
| } |
| |
| @Override |
| public List<UserVmResponse> createUserVmResponse(String objectName, UserVm... userVms) { |
| Account caller = UserContext.current().getCaller(); |
| boolean caller_is_admin = ((caller == null) || (caller.getType() == Account.ACCOUNT_TYPE_ADMIN)); |
| |
| Hashtable<Long, UserVmData> vmDataList = new Hashtable<Long, UserVmData>(); |
| // Initialise the vmdatalist with the input data |
| for (UserVm userVm : userVms) { |
| UserVmData userVmData = newUserVmData(userVm); |
| vmDataList.put(userVm.getId(), userVmData); |
| } |
| |
| vmDataList = ApiDBUtils.listVmDetails(vmDataList); |
| |
| // initialize vmresponse from vmdatalist |
| List<UserVmResponse> vmResponses = new ArrayList<UserVmResponse>(); |
| DecimalFormat decimalFormat = new DecimalFormat("#.##"); |
| for (UserVmData uvd : vmDataList.values()) { |
| UserVmResponse userVmResponse = newUserVmResponse(uvd, caller_is_admin); |
| |
| // stats calculation |
| String cpuUsed = null; |
| // VmStats vmStats = ApiDBUtils.getVmStatistics(userVmResponse.getId()); |
| VmStats vmStats = ApiDBUtils.getVmStatistics(uvd.getId()); |
| if (vmStats != null) { |
| float cpuUtil = (float) vmStats.getCPUUtilization(); |
| cpuUsed = decimalFormat.format(cpuUtil) + "%"; |
| userVmResponse.setCpuUsed(cpuUsed); |
| |
| Double networkKbRead = Double.valueOf(vmStats.getNetworkReadKBs()); |
| userVmResponse.setNetworkKbsRead(networkKbRead.longValue()); |
| |
| Double networkKbWrite = Double.valueOf(vmStats.getNetworkWriteKBs()); |
| userVmResponse.setNetworkKbsWrite(networkKbWrite.longValue()); |
| } |
| userVmResponse.setObjectName(objectName); |
| |
| vmResponses.add(userVmResponse); |
| } |
| return vmResponses; |
| } |
| |
| @Override |
| public DomainRouterResponse createDomainRouterResponse(VirtualRouter router) { |
| Account caller = UserContext.current().getCaller(); |
| Map<Long, ServiceOffering> serviceOfferings = new HashMap<Long, ServiceOffering>(); |
| |
| DomainRouterResponse routerResponse = new DomainRouterResponse(); |
| routerResponse.setId(router.getId()); |
| routerResponse.setZoneId(router.getDataCenterIdToDeployIn()); |
| routerResponse.setName(router.getHostName()); |
| routerResponse.setTemplateId(router.getTemplateId()); |
| routerResponse.setCreated(router.getCreated()); |
| routerResponse.setState(router.getState()); |
| routerResponse.setIsRedundantRouter(router.getIsRedundantRouter()); |
| routerResponse.setRedundantState(router.getRedundantState().toString()); |
| |
| if (caller.getType() == Account.ACCOUNT_TYPE_RESOURCE_DOMAIN_ADMIN || caller.getType() == Account.ACCOUNT_TYPE_ADMIN) { |
| if (router.getHostId() != null) { |
| routerResponse.setHostId(router.getHostId()); |
| routerResponse.setHostName(ApiDBUtils.findHostById(router.getHostId()).getName()); |
| } |
| routerResponse.setPodId(router.getPodIdToDeployIn()); |
| List<NicProfile> nicProfiles = ApiDBUtils.getNics(router); |
| List<NicResponse> nicResponses = new ArrayList<NicResponse>(); |
| for (NicProfile singleNicProfile : nicProfiles) { |
| Network network = ApiDBUtils.findNetworkById(singleNicProfile.getNetworkId()); |
| //legacy code, public/control/guest nic info is kept in nics response object |
| if (network != null) { |
| if (network.getTrafficType() == TrafficType.Public) { |
| routerResponse.setPublicIp(singleNicProfile.getIp4Address()); |
| routerResponse.setPublicMacAddress(singleNicProfile.getMacAddress()); |
| routerResponse.setPublicNetmask(singleNicProfile.getNetmask()); |
| routerResponse.setGateway(singleNicProfile.getGateway()); |
| routerResponse.setPublicNetworkId(singleNicProfile.getNetworkId()); |
| } else if (network.getTrafficType() == TrafficType.Control) { |
| routerResponse.setLinkLocalIp(singleNicProfile.getIp4Address()); |
| routerResponse.setLinkLocalMacAddress(singleNicProfile.getMacAddress()); |
| routerResponse.setLinkLocalNetmask(singleNicProfile.getNetmask()); |
| routerResponse.setLinkLocalNetworkId(singleNicProfile.getNetworkId()); |
| } else if (network.getTrafficType() == TrafficType.Guest) { |
| routerResponse.setGuestIpAddress(singleNicProfile.getIp4Address()); |
| routerResponse.setGuestMacAddress(singleNicProfile.getMacAddress()); |
| routerResponse.setGuestNetmask(singleNicProfile.getNetmask()); |
| routerResponse.setGuestIp6Address(singleNicProfile.getIp6Address()); |
| routerResponse.setGuestIp6Cidr(singleNicProfile.getIp6Cidr()); |
| routerResponse.setGuestNetworkId(singleNicProfile.getNetworkId()); |
| routerResponse.setNetworkDomain(network.getNetworkDomain()); |
| } |
| |
| NicResponse nicResponse = new NicResponse(); |
| nicResponse.setId(singleNicProfile.getId()); |
| nicResponse.setIpaddress(singleNicProfile.getIp4Address()); |
| nicResponse.setGateway(singleNicProfile.getGateway()); |
| nicResponse.setNetmask(singleNicProfile.getNetmask()); |
| nicResponse.setIp6Address(singleNicProfile.getIp6Address()); |
| nicResponse.setIp6Gateway(singleNicProfile.getIp6Gateway()); |
| nicResponse.setIp6Cidr(singleNicProfile.getIp6Cidr()); |
| nicResponse.setNetworkid(singleNicProfile.getNetworkId()); |
| nicResponse.setNetworkName(network.getName()); |
| |
| if (singleNicProfile.getBroadCastUri() != null) { |
| nicResponse.setBroadcastUri(singleNicProfile.getBroadCastUri().toString()); |
| } |
| if (singleNicProfile.getIsolationUri() != null) { |
| nicResponse.setIsolationUri(singleNicProfile.getIsolationUri().toString()); |
| } |
| |
| nicResponse.setTrafficType(network.getTrafficType().toString()); |
| if (network.getGuestType() != null) { |
| nicResponse.setType(network.getGuestType().toString()); |
| } |
| nicResponse.setIsDefault(singleNicProfile.isDefaultNic()); |
| nicResponse.setObjectName("nic"); |
| nicResponses.add(nicResponse); |
| } |
| } |
| routerResponse.setNics(nicResponses); |
| } |
| |
| // Service Offering Info |
| ServiceOffering offering = serviceOfferings.get(router.getServiceOfferingId()); |
| |
| if (offering == null) { |
| offering = ApiDBUtils.findServiceOfferingById(router.getServiceOfferingId()); |
| serviceOfferings.put(offering.getId(), offering); |
| } |
| routerResponse.setServiceOfferingId(offering.getId()); |
| routerResponse.setServiceOfferingName(offering.getName()); |
| |
| populateOwner(routerResponse, router); |
| |
| DataCenter zone = ApiDBUtils.findZoneById(router.getDataCenterIdToDeployIn()); |
| if (zone != null) { |
| routerResponse.setZoneName(zone.getName()); |
| routerResponse.setDns1(zone.getDns1()); |
| routerResponse.setDns2(zone.getDns2()); |
| } |
| |
| routerResponse.setVpcId(router.getVpcId()); |
| |
| routerResponse.setObjectName("domainrouter"); |
| return routerResponse; |
| } |
| |
| @Override |
| public SystemVmResponse createSystemVmResponse(VirtualMachine vm) { |
| SystemVmResponse vmResponse = new SystemVmResponse(); |
| if (vm.getType() == Type.SecondaryStorageVm || vm.getType() == Type.ConsoleProxy) { |
| // SystemVm vm = (SystemVm) systemVM; |
| vmResponse.setId(vm.getId()); |
| vmResponse.setObjectId(vm.getId()); |
| vmResponse.setSystemVmType(vm.getType().toString().toLowerCase()); |
| vmResponse.setZoneId(vm.getDataCenterIdToDeployIn()); |
| |
| vmResponse.setName(vm.getHostName()); |
| vmResponse.setPodId(vm.getPodIdToDeployIn()); |
| 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()); |
| } |
| |
| // for console proxies, add the active sessions |
| if (vm.getType() == Type.ConsoleProxy) { |
| ConsoleProxyVO proxy = ApiDBUtils.findConsoleProxy(vm.getId()); |
| // proxy can be already destroyed |
| if (proxy != null) { |
| vmResponse.setActiveViewerSessions(proxy.getActiveSession()); |
| } |
| } |
| |
| DataCenter zone = ApiDBUtils.findZoneById(vm.getDataCenterIdToDeployIn()); |
| if (zone != null) { |
| vmResponse.setZoneName(zone.getName()); |
| vmResponse.setDns1(zone.getDns1()); |
| vmResponse.setDns2(zone.getDns2()); |
| } |
| |
| List<NicProfile> nicProfiles = ApiDBUtils.getNics(vm); |
| for (NicProfile singleNicProfile : nicProfiles) { |
| Network network = ApiDBUtils.findNetworkById(singleNicProfile.getNetworkId()); |
| if (network != null) { |
| if (network.getTrafficType() == TrafficType.Management) { |
| vmResponse.setPrivateIp(singleNicProfile.getIp4Address()); |
| vmResponse.setPrivateMacAddress(singleNicProfile.getMacAddress()); |
| vmResponse.setPrivateNetmask(singleNicProfile.getNetmask()); |
| } else if (network.getTrafficType() == TrafficType.Control) { |
| vmResponse.setLinkLocalIp(singleNicProfile.getIp4Address()); |
| vmResponse.setLinkLocalMacAddress(singleNicProfile.getMacAddress()); |
| vmResponse.setLinkLocalNetmask(singleNicProfile.getNetmask()); |
| } else if (network.getTrafficType() == TrafficType.Public || network.getTrafficType() == TrafficType.Guest) { |
| /*In basic zone, public ip has TrafficType.Guest*/ |
| vmResponse.setPublicIp(singleNicProfile.getIp4Address()); |
| vmResponse.setPublicMacAddress(singleNicProfile.getMacAddress()); |
| vmResponse.setPublicNetmask(singleNicProfile.getNetmask()); |
| vmResponse.setGateway(singleNicProfile.getGateway()); |
| } |
| } |
| } |
| } |
| vmResponse.setObjectName("systemvm"); |
| return vmResponse; |
| } |
| |
| @Override |
| public Host findHostById(Long hostId) { |
| return ApiDBUtils.findHostById(hostId); |
| } |
| |
| @Override |
| public User findUserById(Long userId) { |
| return ApiDBUtils.findUserById(userId); |
| } |
| |
| @Override |
| public UserVm findUserVmById(Long vmId) { |
| return ApiDBUtils.findUserVmById(vmId); |
| |
| } |
| |
| @Override |
| public VolumeVO findVolumeById(Long volumeId) { |
| return ApiDBUtils.findVolumeById(volumeId); |
| } |
| |
| @Override |
| public Account findAccountByNameDomain(String accountName, Long domainId) { |
| return ApiDBUtils.findAccountByNameDomain(accountName, domainId); |
| } |
| |
| @Override |
| public VirtualMachineTemplate findTemplateById(Long templateId) { |
| return ApiDBUtils.findTemplateById(templateId); |
| } |
| |
| @Override |
| public VpnUsersResponse createVpnUserResponse(VpnUser vpnUser) { |
| VpnUsersResponse vpnResponse = new VpnUsersResponse(); |
| vpnResponse.setId(vpnUser.getId()); |
| vpnResponse.setUserName(vpnUser.getUsername()); |
| |
| populateOwner(vpnResponse, vpnUser); |
| |
| vpnResponse.setObjectName("vpnuser"); |
| return vpnResponse; |
| } |
| |
| @Override |
| public RemoteAccessVpnResponse createRemoteAccessVpnResponse(RemoteAccessVpn vpn) { |
| RemoteAccessVpnResponse vpnResponse = new RemoteAccessVpnResponse(); |
| vpnResponse.setPublicIpId(vpn.getServerAddressId()); |
| vpnResponse.setPublicIp(ApiDBUtils.findIpAddressById(vpn.getServerAddressId()).getAddress().addr()); |
| vpnResponse.setIpRange(vpn.getIpRange()); |
| vpnResponse.setPresharedKey(vpn.getIpsecPresharedKey()); |
| vpnResponse.setDomainId(vpn.getDomainId()); |
| |
| populateOwner(vpnResponse, vpn); |
| |
| vpnResponse.setState(vpn.getState().toString()); |
| vpnResponse.setObjectName("remoteaccessvpn"); |
| |
| return vpnResponse; |
| } |
| |
| @Override |
| public TemplateResponse createIsoResponse(VirtualMachineTemplate result) { |
| TemplateResponse response = new TemplateResponse(); |
| response.setId(result.getId()); |
| response.setName(result.getName()); |
| response.setDisplayText(result.getDisplayText()); |
| response.setPublic(result.isPublicTemplate()); |
| response.setCreated(result.getCreated()); |
| response.setFormat(result.getFormat()); |
| response.setOsTypeId(result.getGuestOSId()); |
| response.setOsTypeName(ApiDBUtils.findGuestOSById(result.getGuestOSId()).getDisplayName()); |
| response.setDetails(result.getDetails()); |
| Account caller = UserContext.current().getCaller(); |
| |
| if (result.getFormat() == ImageFormat.ISO) { // Templates are always bootable |
| response.setBootable(result.isBootable()); |
| } else { |
| response.setHypervisor(result.getHypervisorType().toString());// hypervisors are associated with templates |
| } |
| |
| // add account ID and name |
| Account owner = ApiDBUtils.findAccountById(result.getAccountId()); |
| populateAccount(response, owner.getId()); |
| populateDomain(response, owner.getDomainId()); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = null; |
| if (result.getFormat() == ImageFormat.ISO) { |
| tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.ISO, result.getId()); |
| } else { |
| tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.Template, result.getId()); |
| } |
| |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| response.setTags(tagResponses); |
| |
| response.setObjectName("iso"); |
| return response; |
| } |
| |
| @Override |
| public List<TemplateResponse> createTemplateResponses(long templateId, Long zoneId, boolean readyOnly) { |
| if (zoneId == null || zoneId == -1) { |
| List<TemplateResponse> responses = new ArrayList<TemplateResponse>(); |
| List<DataCenterVO> dcs = new ArrayList<DataCenterVO>(); |
| responses = createSwiftTemplateResponses(templateId); |
| if (!responses.isEmpty()) { |
| return responses; |
| } |
| dcs.addAll(ApiDBUtils.listZones()); |
| for (DataCenterVO dc : dcs) { |
| responses.addAll(createTemplateResponses(templateId, dc.getId(), readyOnly)); |
| } |
| return responses; |
| } else { |
| return createTemplateResponses(templateId, zoneId.longValue(), readyOnly); |
| } |
| } |
| |
| private List<TemplateResponse> createSwiftTemplateResponses(long templateId) { |
| VirtualMachineTemplate template = findTemplateById(templateId); |
| List<TemplateResponse> responses = new ArrayList<TemplateResponse>(); |
| VMTemplateSwiftVO templateSwiftRef = ApiDBUtils.findTemplateSwiftRef(templateId); |
| if (templateSwiftRef == null) { |
| return responses; |
| } |
| |
| TemplateResponse templateResponse = new TemplateResponse(); |
| templateResponse.setId(template.getId()); |
| templateResponse.setName(template.getName()); |
| templateResponse.setDisplayText(template.getDisplayText()); |
| templateResponse.setPublic(template.isPublicTemplate()); |
| templateResponse.setCreated(templateSwiftRef.getCreated()); |
| |
| templateResponse.setReady(true); |
| templateResponse.setFeatured(template.isFeatured()); |
| templateResponse.setExtractable(template.isExtractable() && !(template.getTemplateType() == TemplateType.SYSTEM)); |
| templateResponse.setPasswordEnabled(template.getEnablePassword()); |
| templateResponse.setCrossZones(template.isCrossZones()); |
| templateResponse.setFormat(template.getFormat()); |
| templateResponse.setDetails(template.getDetails()); |
| if (template.getTemplateType() != null) { |
| templateResponse.setTemplateType(template.getTemplateType().toString()); |
| } |
| |
| templateResponse.setHypervisor(template.getHypervisorType().toString()); |
| |
| GuestOS os = ApiDBUtils.findGuestOSById(template.getGuestOSId()); |
| if (os != null) { |
| templateResponse.setOsTypeId(os.getId()); |
| templateResponse.setOsTypeName(os.getDisplayName()); |
| } else { |
| templateResponse.setOsTypeId(-1L); |
| templateResponse.setOsTypeName(""); |
| } |
| |
| Account account = ApiDBUtils.findAccountByIdIncludingRemoved(template.getAccountId()); |
| populateAccount(templateResponse, account.getId()); |
| populateDomain(templateResponse, account.getDomainId()); |
| |
| Account caller = UserContext.current().getCaller(); |
| boolean isAdmin = false; |
| if (BaseCmd.isAdmin(caller.getType())) { |
| isAdmin = true; |
| } |
| |
| // If the user is an Admin, add the template download status |
| if (isAdmin || caller.getId() == template.getAccountId()) { |
| // add download status |
| templateResponse.setStatus("Successfully Installed"); |
| } |
| |
| Long templateSize = templateSwiftRef.getSize(); |
| if (templateSize > 0) { |
| templateResponse.setSize(templateSize); |
| } |
| |
| templateResponse.setChecksum(template.getChecksum()); |
| templateResponse.setSourceTemplateId(template.getSourceTemplateId()); |
| |
| templateResponse.setChecksum(template.getChecksum()); |
| |
| templateResponse.setTemplateTag(template.getTemplateTag()); |
| |
| templateResponse.setObjectName("template"); |
| responses.add(templateResponse); |
| return responses; |
| } |
| |
| @Override |
| public List<TemplateResponse> createTemplateResponses(long templateId, long zoneId, boolean readyOnly) { |
| VirtualMachineTemplate template = findTemplateById(templateId); |
| List<TemplateResponse> responses = new ArrayList<TemplateResponse>(); |
| VMTemplateHostVO templateHostRef = ApiDBUtils.findTemplateHostRef(templateId, zoneId, readyOnly); |
| if (templateHostRef == null) { |
| return responses; |
| } |
| |
| HostVO host = ApiDBUtils.findHostById(templateHostRef.getHostId()); |
| if (host.getType() == Host.Type.LocalSecondaryStorage && host.getStatus() != com.cloud.host.Status.Up) { |
| return responses; |
| } |
| |
| TemplateResponse templateResponse = new TemplateResponse(); |
| templateResponse.setId(template.getId()); |
| templateResponse.setName(template.getName()); |
| templateResponse.setDisplayText(template.getDisplayText()); |
| templateResponse.setPublic(template.isPublicTemplate()); |
| templateResponse.setCreated(templateHostRef.getCreated()); |
| |
| templateResponse.setReady(templateHostRef.getDownloadState() == Status.DOWNLOADED); |
| templateResponse.setFeatured(template.isFeatured()); |
| templateResponse.setExtractable(template.isExtractable() && !(template.getTemplateType() == TemplateType.SYSTEM)); |
| templateResponse.setPasswordEnabled(template.getEnablePassword()); |
| templateResponse.setCrossZones(template.isCrossZones()); |
| templateResponse.setFormat(template.getFormat()); |
| if (template.getTemplateType() != null) { |
| templateResponse.setTemplateType(template.getTemplateType().toString()); |
| } |
| |
| templateResponse.setHypervisor(template.getHypervisorType().toString()); |
| templateResponse.setDetails(template.getDetails()); |
| |
| GuestOS os = ApiDBUtils.findGuestOSById(template.getGuestOSId()); |
| if (os != null) { |
| templateResponse.setOsTypeId(os.getId()); |
| templateResponse.setOsTypeName(os.getDisplayName()); |
| } else { |
| templateResponse.setOsTypeId(-1L); |
| templateResponse.setOsTypeName(""); |
| } |
| |
| Account account = ApiDBUtils.findAccountByIdIncludingRemoved(template.getAccountId()); |
| populateAccount(templateResponse, account.getId()); |
| populateDomain(templateResponse, account.getDomainId()); |
| |
| DataCenterVO datacenter = ApiDBUtils.findZoneById(zoneId); |
| |
| // Add the zone ID |
| templateResponse.setZoneId(zoneId); |
| templateResponse.setZoneName(datacenter.getName()); |
| |
| boolean isAdmin = false; |
| Account caller = UserContext.current().getCaller(); |
| if ((caller == null) || BaseCmd.isAdmin(caller.getType())) { |
| isAdmin = true; |
| } |
| |
| // If the user is an Admin, add the template download status |
| if (isAdmin || caller.getId() == template.getAccountId()) { |
| // add download status |
| if (templateHostRef.getDownloadState() != Status.DOWNLOADED) { |
| String templateStatus = "Processing"; |
| if (templateHostRef.getDownloadState() == VMTemplateHostVO.Status.DOWNLOAD_IN_PROGRESS) { |
| if (templateHostRef.getDownloadPercent() == 100) { |
| templateStatus = "Installing Template"; |
| } else { |
| templateStatus = templateHostRef.getDownloadPercent() + "% Downloaded"; |
| } |
| } else { |
| templateStatus = templateHostRef.getErrorString(); |
| } |
| templateResponse.setStatus(templateStatus); |
| } else if (templateHostRef.getDownloadState() == VMTemplateHostVO.Status.DOWNLOADED) { |
| templateResponse.setStatus("Download Complete"); |
| } else { |
| templateResponse.setStatus("Successfully Installed"); |
| } |
| } |
| |
| Long templateSize = templateHostRef.getSize(); |
| if (templateSize > 0) { |
| templateResponse.setSize(templateSize); |
| } |
| |
| templateResponse.setChecksum(template.getChecksum()); |
| templateResponse.setSourceTemplateId(template.getSourceTemplateId()); |
| |
| templateResponse.setChecksum(template.getChecksum()); |
| |
| templateResponse.setTemplateTag(template.getTemplateTag()); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = null; |
| if (template.getFormat() == ImageFormat.ISO) { |
| tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.ISO, template.getId()); |
| } else { |
| tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.Template, template.getId()); |
| } |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| templateResponse.setTags(tagResponses); |
| |
| templateResponse.setObjectName("template"); |
| responses.add(templateResponse); |
| return responses; |
| } |
| |
| @Override |
| public List<TemplateResponse> createIsoResponses(long isoId, Long zoneId, boolean readyOnly) { |
| |
| final List<TemplateResponse> isoResponses = new ArrayList<TemplateResponse>(); |
| VirtualMachineTemplate iso = findTemplateById(isoId); |
| if (iso.getTemplateType() == TemplateType.PERHOST) { |
| TemplateResponse isoResponse = new TemplateResponse(); |
| isoResponse.setId(iso.getId()); |
| isoResponse.setName(iso.getName()); |
| isoResponse.setDisplayText(iso.getDisplayText()); |
| isoResponse.setPublic(iso.isPublicTemplate()); |
| isoResponse.setExtractable(iso.isExtractable() && !(iso.getTemplateType() == TemplateType.PERHOST)); |
| isoResponse.setReady(true); |
| isoResponse.setBootable(iso.isBootable()); |
| isoResponse.setFeatured(iso.isFeatured()); |
| isoResponse.setCrossZones(iso.isCrossZones()); |
| isoResponse.setPublic(iso.isPublicTemplate()); |
| isoResponse.setCreated(iso.getCreated()); |
| isoResponse.setChecksum(iso.getChecksum()); |
| isoResponse.setPasswordEnabled(false); |
| isoResponse.setDetails(iso.getDetails()); |
| |
| // add account ID and name |
| Account owner = ApiDBUtils.findAccountById(iso.getAccountId()); |
| populateAccount(isoResponse, owner.getId()); |
| populateDomain(isoResponse, owner.getDomainId()); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.ISO, iso.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| isoResponse.setTags(tagResponses); |
| |
| isoResponse.setObjectName("iso"); |
| isoResponses.add(isoResponse); |
| return isoResponses; |
| } else { |
| if (zoneId == null || zoneId == -1) { |
| isoResponses.addAll(createSwiftIsoResponses(iso)); |
| if (!isoResponses.isEmpty()) { |
| return isoResponses; |
| } |
| |
| isoResponses.addAll(createS3IsoResponses(iso)); |
| if (!isoResponses.isEmpty()) { |
| return isoResponses; |
| } |
| |
| final List<DataCenterVO> dcs = new ArrayList<DataCenterVO>(); |
| dcs.addAll(ApiDBUtils.listZones()); |
| for (DataCenterVO dc : dcs) { |
| isoResponses.addAll(createIsoResponses(iso, dc.getId(), readyOnly)); |
| } |
| return isoResponses; |
| } else { |
| return createIsoResponses(iso, zoneId, readyOnly); |
| } |
| } |
| } |
| |
| private List<? extends TemplateResponse> createS3IsoResponses(final VirtualMachineTemplate iso) { |
| |
| final VMTemplateS3VO s3Iso = ApiDBUtils.findTemplateS3Ref(iso.getId()); |
| |
| if (s3Iso == null) { |
| return emptyList(); |
| } |
| |
| final TemplateResponse templateResponse = new TemplateResponse(); |
| |
| templateResponse.setId(iso.getId()); |
| templateResponse.setName(iso.getName()); |
| templateResponse.setDisplayText(iso.getDisplayText()); |
| templateResponse.setPublic(iso.isPublicTemplate()); |
| templateResponse.setExtractable(iso.isExtractable()); |
| templateResponse.setCreated(s3Iso.getCreated()); |
| templateResponse.setReady(true); |
| templateResponse.setBootable(iso.isBootable()); |
| templateResponse.setFeatured(iso.isFeatured()); |
| templateResponse.setCrossZones(iso.isCrossZones()); |
| templateResponse.setChecksum(iso.getChecksum()); |
| templateResponse.setDetails(iso.getDetails()); |
| |
| final GuestOS os = ApiDBUtils.findGuestOSById(iso.getGuestOSId()); |
| |
| if (os != null) { |
| templateResponse.setOsTypeId(os.getId()); |
| templateResponse.setOsTypeName(os.getDisplayName()); |
| } else { |
| templateResponse.setOsTypeId(-1L); |
| templateResponse.setOsTypeName(""); |
| } |
| |
| final Account account = ApiDBUtils.findAccountByIdIncludingRemoved(iso.getAccountId()); |
| populateAccount(templateResponse, account.getId()); |
| populateDomain(templateResponse, account.getDomainId()); |
| |
| boolean isAdmin = false; |
| if ((account == null) || BaseCmd.isAdmin(account.getType())) { |
| isAdmin = true; |
| } |
| |
| // If the user is an admin, add the template download status |
| if (isAdmin || account.getId() == iso.getAccountId()) { |
| // add download status |
| templateResponse.setStatus("Successfully Installed"); |
| } |
| |
| final Long isoSize = s3Iso.getSize(); |
| if (isoSize > 0) { |
| templateResponse.setSize(isoSize); |
| } |
| |
| templateResponse.setObjectName("iso"); |
| |
| return singletonList(templateResponse); |
| |
| } |
| |
| private List<TemplateResponse> createSwiftIsoResponses(VirtualMachineTemplate iso) { |
| long isoId = iso.getId(); |
| List<TemplateResponse> isoResponses = new ArrayList<TemplateResponse>(); |
| VMTemplateSwiftVO isoSwift = ApiDBUtils.findTemplateSwiftRef(isoId); |
| if (isoSwift == null) { |
| return isoResponses; |
| } |
| TemplateResponse isoResponse = new TemplateResponse(); |
| isoResponse.setId(iso.getId()); |
| isoResponse.setName(iso.getName()); |
| isoResponse.setDisplayText(iso.getDisplayText()); |
| isoResponse.setPublic(iso.isPublicTemplate()); |
| isoResponse.setExtractable(iso.isExtractable() && !(iso.getTemplateType() == TemplateType.PERHOST)); |
| isoResponse.setCreated(isoSwift.getCreated()); |
| isoResponse.setReady(true); |
| isoResponse.setBootable(iso.isBootable()); |
| isoResponse.setFeatured(iso.isFeatured()); |
| isoResponse.setCrossZones(iso.isCrossZones()); |
| isoResponse.setPublic(iso.isPublicTemplate()); |
| isoResponse.setChecksum(iso.getChecksum()); |
| isoResponse.setDetails(iso.getDetails()); |
| |
| // TODO: implement |
| GuestOS os = ApiDBUtils.findGuestOSById(iso.getGuestOSId()); |
| if (os != null) { |
| isoResponse.setOsTypeId(os.getId()); |
| isoResponse.setOsTypeName(os.getDisplayName()); |
| } else { |
| isoResponse.setOsTypeId(-1L); |
| isoResponse.setOsTypeName(""); |
| } |
| Account account = ApiDBUtils.findAccountByIdIncludingRemoved(iso.getAccountId()); |
| populateAccount(isoResponse, account.getId()); |
| populateDomain(isoResponse, account.getDomainId()); |
| boolean isAdmin = false; |
| if ((account == null) || BaseCmd.isAdmin(account.getType())) { |
| isAdmin = true; |
| } |
| |
| // If the user is an admin, add the template download status |
| if (isAdmin || account.getId() == iso.getAccountId()) { |
| // add download status |
| isoResponse.setStatus("Successfully Installed"); |
| } |
| Long isoSize = isoSwift.getSize(); |
| if (isoSize > 0) { |
| isoResponse.setSize(isoSize); |
| } |
| isoResponse.setObjectName("iso"); |
| isoResponses.add(isoResponse); |
| return isoResponses; |
| } |
| |
| @Override |
| public List<TemplateResponse> createIsoResponses(VirtualMachineTemplate iso, long zoneId, boolean readyOnly) { |
| long isoId = iso.getId(); |
| List<TemplateResponse> isoResponses = new ArrayList<TemplateResponse>(); |
| VMTemplateHostVO isoHost = ApiDBUtils.findTemplateHostRef(isoId, zoneId, readyOnly); |
| if (isoHost == null) { |
| return isoResponses; |
| } |
| TemplateResponse isoResponse = new TemplateResponse(); |
| isoResponse.setId(iso.getId()); |
| isoResponse.setName(iso.getName()); |
| isoResponse.setDisplayText(iso.getDisplayText()); |
| isoResponse.setPublic(iso.isPublicTemplate()); |
| isoResponse.setExtractable(iso.isExtractable() && !(iso.getTemplateType() == TemplateType.PERHOST)); |
| isoResponse.setCreated(isoHost.getCreated()); |
| isoResponse.setReady(isoHost.getDownloadState() == Status.DOWNLOADED); |
| isoResponse.setBootable(iso.isBootable()); |
| isoResponse.setFeatured(iso.isFeatured()); |
| isoResponse.setCrossZones(iso.isCrossZones()); |
| isoResponse.setPublic(iso.isPublicTemplate()); |
| isoResponse.setChecksum(iso.getChecksum()); |
| isoResponse.setDetails(iso.getDetails()); |
| |
| // TODO: implement |
| GuestOS os = ApiDBUtils.findGuestOSById(iso.getGuestOSId()); |
| if (os != null) { |
| isoResponse.setOsTypeId(os.getId()); |
| isoResponse.setOsTypeName(os.getDisplayName()); |
| } else { |
| isoResponse.setOsTypeId(-1L); |
| isoResponse.setOsTypeName(""); |
| } |
| |
| Account account = ApiDBUtils.findAccountByIdIncludingRemoved(iso.getAccountId()); |
| populateAccount(isoResponse, account.getId()); |
| populateDomain(isoResponse, account.getDomainId()); |
| |
| Account caller = UserContext.current().getCaller(); |
| boolean isAdmin = false; |
| if ((caller == null) || BaseCmd.isAdmin(caller.getType())) { |
| isAdmin = true; |
| } |
| // Add the zone ID |
| DataCenterVO datacenter = ApiDBUtils.findZoneById(zoneId); |
| isoResponse.setZoneId(zoneId); |
| isoResponse.setZoneName(datacenter.getName()); |
| |
| // If the user is an admin, add the template download status |
| if (isAdmin || caller.getId() == iso.getAccountId()) { |
| // add download status |
| if (isoHost.getDownloadState() != Status.DOWNLOADED) { |
| String isoStatus = "Processing"; |
| if (isoHost.getDownloadState() == VMTemplateHostVO.Status.DOWNLOADED) { |
| isoStatus = "Download Complete"; |
| } else if (isoHost.getDownloadState() == VMTemplateHostVO.Status.DOWNLOAD_IN_PROGRESS) { |
| if (isoHost.getDownloadPercent() == 100) { |
| isoStatus = "Installing ISO"; |
| } else { |
| isoStatus = isoHost.getDownloadPercent() + "% Downloaded"; |
| } |
| } else { |
| isoStatus = isoHost.getErrorString(); |
| } |
| isoResponse.setStatus(isoStatus); |
| } else { |
| isoResponse.setStatus("Successfully Installed"); |
| } |
| } |
| |
| Long isoSize = isoHost.getSize(); |
| if (isoSize > 0) { |
| isoResponse.setSize(isoSize); |
| } |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.ISO, iso.getId()); |
| |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| isoResponse.setTags(tagResponses); |
| |
| isoResponse.setObjectName("iso"); |
| isoResponses.add(isoResponse); |
| return isoResponses; |
| } |
| |
| @Override |
| public ListResponse<SecurityGroupResponse> createSecurityGroupResponses( |
| List<? extends SecurityGroupRules> networkGroups) { |
| List<SecurityGroupResultObject> groupResultObjs = SecurityGroupResultObject |
| .transposeNetworkGroups(networkGroups); |
| |
| ListResponse<SecurityGroupResponse> response = new ListResponse<SecurityGroupResponse>(); |
| List<SecurityGroupResponse> netGrpResponses = new ArrayList<SecurityGroupResponse>(); |
| for (SecurityGroupResultObject networkGroup : groupResultObjs) { |
| SecurityGroupResponse netGrpResponse = new SecurityGroupResponse(); |
| netGrpResponse.setId(networkGroup.getId()); |
| netGrpResponse.setName(networkGroup.getName()); |
| netGrpResponse.setDescription(networkGroup.getDescription()); |
| |
| populateOwner(netGrpResponse, networkGroup); |
| |
| List<SecurityGroupRuleResultObject> securityGroupRules = networkGroup |
| .getSecurityGroupRules(); |
| if ((securityGroupRules != null) && !securityGroupRules.isEmpty()) { |
| List<SecurityGroupRuleResponse> ingressRulesResponse = new ArrayList<SecurityGroupRuleResponse>(); |
| List<SecurityGroupRuleResponse> egressRulesResponse = new ArrayList<SecurityGroupRuleResponse>(); |
| for (SecurityGroupRuleResultObject securityGroupRule : securityGroupRules) { |
| SecurityGroupRuleResponse ruleData = new SecurityGroupRuleResponse(); |
| ruleData.setRuleId(securityGroupRule.getId()); |
| ruleData.setProtocol(securityGroupRule.getProtocol()); |
| |
| if ("icmp".equalsIgnoreCase(securityGroupRule.getProtocol())) { |
| ruleData.setIcmpType(securityGroupRule.getStartPort()); |
| ruleData.setIcmpCode(securityGroupRule.getEndPort()); |
| } else { |
| ruleData.setStartPort(securityGroupRule.getStartPort()); |
| ruleData.setEndPort(securityGroupRule.getEndPort()); |
| } |
| |
| if (securityGroupRule.getAllowedSecurityGroup() != null) { |
| ruleData.setSecurityGroupName(securityGroupRule |
| .getAllowedSecurityGroup()); |
| ruleData.setAccountName(securityGroupRule |
| .getAllowedSecGroupAcct()); |
| } else { |
| ruleData.setCidr(securityGroupRule |
| .getAllowedSourceIpCidr()); |
| } |
| |
| if (securityGroupRule.getRuleType() == SecurityRuleType.IngressRule) { |
| ruleData.setObjectName("ingressrule"); |
| ingressRulesResponse.add(ruleData); |
| } else { |
| ruleData.setObjectName("egressrule"); |
| egressRulesResponse.add(ruleData); |
| } |
| } |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.UserVm, networkGroup.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| netGrpResponse.setTags(tagResponses); |
| |
| netGrpResponse |
| .setSecurityGroupIngressRules(ingressRulesResponse); |
| netGrpResponse.setSecurityGroupEgressRules(egressRulesResponse); |
| } |
| netGrpResponse.setObjectName("securitygroup"); |
| netGrpResponses.add(netGrpResponse); |
| } |
| |
| response.setResponses(netGrpResponses); |
| return response; |
| } |
| |
| @Override |
| public SecurityGroupResponse createSecurityGroupResponse(SecurityGroup group) { |
| SecurityGroupResponse response = new SecurityGroupResponse(); |
| |
| populateOwner(response, group); |
| |
| response.setDescription(group.getDescription()); |
| response.setId(group.getId()); |
| response.setName(group.getName()); |
| |
| response.setObjectName("securitygroup"); |
| return response; |
| |
| } |
| |
| @Override |
| public ExtractResponse createExtractResponse(Long uploadId, Long id, Long zoneId, Long accountId, String mode) { |
| UploadVO uploadInfo = ApiDBUtils.findUploadById(uploadId); |
| ExtractResponse response = new ExtractResponse(); |
| response.setObjectName("template"); |
| response.setId(id); |
| response.setName(ApiDBUtils.findTemplateById(id).getName()); |
| if (zoneId != null) { |
| response.setZoneId(zoneId); |
| response.setZoneName(ApiDBUtils.findZoneById(zoneId).getName()); |
| } |
| response.setMode(mode); |
| response.setUploadId(uploadId); |
| response.setState(uploadInfo.getUploadState().toString()); |
| response.setAccountId(accountId); |
| response.setUrl(uploadInfo.getUploadUrl()); |
| return response; |
| |
| } |
| |
| @Override |
| public String toSerializedString(CreateCmdResponse response, String responseType) { |
| return ApiResponseSerializer.toSerializedString(response, responseType); |
| } |
| |
| @Override |
| public AsyncJobResponse createAsyncJobResponse(AsyncJob job) { |
| AsyncJobResponse jobResponse = new AsyncJobResponse(); |
| jobResponse.setAccountId(job.getAccountId()); |
| jobResponse.setUserId(job.getUserId()); |
| jobResponse.setCmd(job.getCmd()); |
| jobResponse.setCreated(job.getCreated()); |
| jobResponse.setJobId(job.getId()); |
| jobResponse.setJobStatus(job.getStatus()); |
| jobResponse.setJobProcStatus(job.getProcessStatus()); |
| |
| if (job.getInstanceType() != null && job.getInstanceId() != null) { |
| jobResponse.setJobInstanceType(job.getInstanceType().toString()); |
| jobResponse.setJobInstanceId(job.getInstanceId()); |
| } |
| jobResponse.setJobResultCode(job.getResultCode()); |
| |
| boolean savedValue = SerializationContext.current().getUuidTranslation(); |
| SerializationContext.current().setUuidTranslation(false); |
| |
| Object resultObject = ApiSerializerHelper.fromSerializedString(job.getResult()); |
| jobResponse.setJobResult((ResponseObject) resultObject); |
| SerializationContext.current().setUuidTranslation(savedValue); |
| |
| if (resultObject != null) { |
| Class<?> clz = resultObject.getClass(); |
| if (clz.isPrimitive() || clz.getSuperclass() == Number.class || clz == String.class || clz == Date.class) { |
| jobResponse.setJobResultType("text"); |
| } else { |
| jobResponse.setJobResultType("object"); |
| } |
| } |
| |
| jobResponse.setObjectName("asyncjobs"); |
| return jobResponse; |
| } |
| |
| @Override |
| public List<TemplateResponse> createTemplateResponses(long templateId, Long snapshotId, Long volumeId, boolean readyOnly) { |
| VolumeVO volume = null; |
| if (snapshotId != null) { |
| Snapshot snapshot = ApiDBUtils.findSnapshotById(snapshotId); |
| volume = findVolumeById(snapshot.getVolumeId()); |
| } else { |
| volume = findVolumeById(volumeId); |
| } |
| return createTemplateResponses(templateId, volume.getDataCenterId(), readyOnly); |
| } |
| |
| @Override |
| public List<TemplateResponse> createTemplateResponses(long templateId, Long vmId) { |
| UserVm vm = findUserVmById(vmId); |
| Long hostId = (vm.getHostId() == null ? vm.getLastHostId() : vm.getHostId()); |
| Host host = findHostById(hostId); |
| return createTemplateResponses(templateId, host.getDataCenterId(), true); |
| } |
| |
| @Override |
| public EventResponse createEventResponse(Event event) { |
| EventResponse responseEvent = new EventResponse(); |
| responseEvent.setCreated(event.getCreateDate()); |
| responseEvent.setDescription(event.getDescription()); |
| responseEvent.setEventType(event.getType()); |
| responseEvent.setId(event.getId()); |
| responseEvent.setLevel(event.getLevel()); |
| responseEvent.setParentId(event.getStartId()); |
| responseEvent.setState(event.getState()); |
| |
| populateOwner(responseEvent, event); |
| |
| User user = ApiDBUtils.findUserById(event.getUserId()); |
| if (user != null) { |
| responseEvent.setUsername(user.getUsername()); |
| } |
| |
| responseEvent.setObjectName("event"); |
| return responseEvent; |
| } |
| |
| private List<CapacityVO> sumCapacities(List<? extends Capacity> hostCapacities) { |
| Map<String, Long> totalCapacityMap = new HashMap<String, Long>(); |
| Map<String, Long> usedCapacityMap = new HashMap<String, Long>(); |
| |
| Set<Long> poolIdsToIgnore = new HashSet<Long>(); |
| Criteria c = new Criteria(); |
| // TODO: implement |
| List<? extends StoragePoolVO> allStoragePools = ApiDBUtils.searchForStoragePools(c); |
| for (StoragePoolVO pool : allStoragePools) { |
| StoragePoolType poolType = pool.getPoolType(); |
| if (!(poolType.isShared())) {// All the non shared storages shouldn't show up in the capacity calculation |
| poolIdsToIgnore.add(pool.getId()); |
| } |
| } |
| |
| float cpuOverprovisioningFactor = ApiDBUtils.getCpuOverprovisioningFactor(); |
| |
| // collect all the capacity types, sum allocated/used and sum total...get one capacity number for each |
| for (Capacity capacity : hostCapacities) { |
| |
| // check if zone exist |
| DataCenter zone = ApiDBUtils.findZoneById(capacity.getDataCenterId()); |
| if (zone == null) { |
| continue; |
| } |
| |
| short capacityType = capacity.getCapacityType(); |
| |
| // If local storage then ignore |
| if ((capacityType == Capacity.CAPACITY_TYPE_STORAGE_ALLOCATED || capacityType == Capacity.CAPACITY_TYPE_STORAGE) |
| && poolIdsToIgnore.contains(capacity.getHostOrPoolId())) { |
| continue; |
| } |
| |
| String key = capacity.getCapacityType() + "_" + capacity.getDataCenterId(); |
| String keyForPodTotal = key + "_-1"; |
| |
| boolean sumPodCapacity = false; |
| if (capacity.getPodId() != null) { |
| key += "_" + capacity.getPodId(); |
| sumPodCapacity = true; |
| } |
| |
| Long totalCapacity = totalCapacityMap.get(key); |
| Long usedCapacity = usedCapacityMap.get(key); |
| |
| // reset overprovisioning factor to 1 |
| float overprovisioningFactor = 1; |
| if (capacityType == Capacity.CAPACITY_TYPE_CPU) { |
| overprovisioningFactor = cpuOverprovisioningFactor; |
| } |
| |
| if (totalCapacity == null) { |
| totalCapacity = new Long((long) (capacity.getTotalCapacity() * overprovisioningFactor)); |
| } else { |
| totalCapacity = new Long((long) (capacity.getTotalCapacity() * overprovisioningFactor)) + totalCapacity; |
| } |
| |
| if (usedCapacity == null) { |
| usedCapacity = new Long(capacity.getUsedCapacity()); |
| } else { |
| usedCapacity = new Long(capacity.getUsedCapacity() + usedCapacity); |
| } |
| |
| if (capacityType == Capacity.CAPACITY_TYPE_CPU || capacityType == Capacity.CAPACITY_TYPE_MEMORY) { // Reserved |
| // Capacity |
| // accounts |
| // for |
| // stopped |
| // vms |
| // that |
| // have been |
| // stopped |
| // within |
| // an |
| // interval |
| usedCapacity += capacity.getReservedCapacity(); |
| } |
| |
| totalCapacityMap.put(key, totalCapacity); |
| usedCapacityMap.put(key, usedCapacity); |
| |
| if (sumPodCapacity) { |
| totalCapacity = totalCapacityMap.get(keyForPodTotal); |
| usedCapacity = usedCapacityMap.get(keyForPodTotal); |
| |
| overprovisioningFactor = 1; |
| if (capacityType == Capacity.CAPACITY_TYPE_CPU) { |
| overprovisioningFactor = cpuOverprovisioningFactor; |
| } |
| |
| if (totalCapacity == null) { |
| totalCapacity = new Long((long) (capacity.getTotalCapacity() * overprovisioningFactor)); |
| } else { |
| totalCapacity = new Long((long) (capacity.getTotalCapacity() * overprovisioningFactor)) + totalCapacity; |
| } |
| |
| if (usedCapacity == null) { |
| usedCapacity = new Long(capacity.getUsedCapacity()); |
| } else { |
| usedCapacity = new Long(capacity.getUsedCapacity() + usedCapacity); |
| } |
| |
| if (capacityType == Capacity.CAPACITY_TYPE_CPU || capacityType == Capacity.CAPACITY_TYPE_MEMORY) { // Reserved |
| // Capacity |
| // accounts |
| // for |
| // stopped |
| // vms |
| // that |
| // have |
| // been |
| // stopped |
| // within |
| // an |
| // interval |
| usedCapacity += capacity.getReservedCapacity(); |
| } |
| |
| totalCapacityMap.put(keyForPodTotal, totalCapacity); |
| usedCapacityMap.put(keyForPodTotal, usedCapacity); |
| } |
| } |
| |
| List<CapacityVO> summedCapacities = new ArrayList<CapacityVO>(); |
| for (String key : totalCapacityMap.keySet()) { |
| CapacityVO summedCapacity = new CapacityVO(); |
| |
| StringTokenizer st = new StringTokenizer(key, "_"); |
| summedCapacity.setCapacityType(Short.parseShort(st.nextToken())); |
| summedCapacity.setDataCenterId(Long.parseLong(st.nextToken())); |
| if (st.hasMoreTokens()) { |
| summedCapacity.setPodId(Long.parseLong(st.nextToken())); |
| } |
| |
| summedCapacity.setTotalCapacity(totalCapacityMap.get(key)); |
| summedCapacity.setUsedCapacity(usedCapacityMap.get(key)); |
| |
| summedCapacities.add(summedCapacity); |
| } |
| return summedCapacities; |
| } |
| |
| @Override |
| public List<CapacityResponse> createCapacityResponse(List<? extends Capacity> result, DecimalFormat format) { |
| List<CapacityResponse> capacityResponses = new ArrayList<CapacityResponse>(); |
| |
| for (Capacity summedCapacity : result) { |
| CapacityResponse capacityResponse = new CapacityResponse(); |
| capacityResponse.setCapacityTotal(summedCapacity.getTotalCapacity()); |
| capacityResponse.setCapacityType(summedCapacity.getCapacityType()); |
| capacityResponse.setCapacityUsed(summedCapacity.getUsedCapacity()); |
| if (summedCapacity.getPodId() != null) { |
| capacityResponse.setPodId(summedCapacity.getPodId()); |
| HostPodVO pod = ApiDBUtils.findPodById(summedCapacity.getPodId()); |
| if (pod != null) { |
| capacityResponse.setPodName(pod.getName()); |
| } |
| } |
| if (summedCapacity.getClusterId() != null) { |
| capacityResponse.setClusterId(summedCapacity.getClusterId()); |
| ClusterVO cluster = ApiDBUtils.findClusterById(summedCapacity.getClusterId()); |
| if (cluster != null) { |
| capacityResponse.setClusterName(cluster.getName()); |
| if (summedCapacity.getPodId() == null) { |
| long podId = cluster.getPodId(); |
| capacityResponse.setPodId(podId); |
| capacityResponse.setPodName(ApiDBUtils.findPodById(podId).getName()); |
| } |
| } |
| } |
| capacityResponse.setZoneId(summedCapacity.getDataCenterId()); |
| capacityResponse.setZoneName(ApiDBUtils.findZoneById(summedCapacity.getDataCenterId()).getName()); |
| if (summedCapacity.getUsedPercentage() != null){ |
| capacityResponse.setPercentUsed(format.format(summedCapacity.getUsedPercentage() * 100f)); |
| } else if (summedCapacity.getTotalCapacity() != 0) { |
| capacityResponse.setPercentUsed(format.format((float) summedCapacity.getUsedCapacity() / (float) summedCapacity.getTotalCapacity() * 100f)); |
| } else { |
| capacityResponse.setPercentUsed(format.format(0L)); |
| } |
| |
| capacityResponse.setObjectName("capacity"); |
| capacityResponses.add(capacityResponse); |
| } |
| |
| return capacityResponses; |
| } |
| |
| @Override |
| public TemplatePermissionsResponse createTemplatePermissionsResponse(List<String> accountNames, Long id, boolean isAdmin) { |
| Long templateOwnerDomain = null; |
| VirtualMachineTemplate template = ApiDBUtils.findTemplateById(id); |
| Account templateOwner = ApiDBUtils.findAccountById(template.getAccountId()); |
| if (isAdmin) { |
| // FIXME: we have just template id and need to get template owner from that |
| if (templateOwner != null) { |
| templateOwnerDomain = templateOwner.getDomainId(); |
| } |
| } |
| |
| TemplatePermissionsResponse response = new TemplatePermissionsResponse(); |
| response.setId(template.getId()); |
| response.setPublicTemplate(template.isPublicTemplate()); |
| if (isAdmin && (templateOwnerDomain != null)) { |
| response.setDomainId(templateOwnerDomain); |
| } |
| |
| // Set accounts |
| List<String> projectIds = new ArrayList<String>(); |
| List<String> regularAccounts = new ArrayList<String>(); |
| for (String accountName : accountNames) { |
| Account account = ApiDBUtils.findAccountByNameDomain(accountName, templateOwner.getDomainId()); |
| if (account.getType() != Account.ACCOUNT_TYPE_PROJECT) { |
| regularAccounts.add(accountName); |
| } else { |
| // convert account to projectIds |
| Project project = ApiDBUtils.findProjectByProjectAccountIdIncludingRemoved(account.getId()); |
| |
| if (project.getUuid() != null && !project.getUuid().isEmpty()) |
| projectIds.add(project.getUuid()); |
| else |
| projectIds.add(String.valueOf(project.getId())); |
| } |
| } |
| |
| if (!projectIds.isEmpty()) { |
| response.setProjectIds(projectIds); |
| } |
| |
| if (!regularAccounts.isEmpty()) { |
| response.setAccountNames(regularAccounts); |
| } |
| |
| response.setObjectName("templatepermission"); |
| return response; |
| } |
| |
| @Override |
| public AsyncJobResponse queryJobResult(QueryAsyncJobResultCmd cmd) { |
| AsyncJob result = ApiDBUtils._asyncMgr.queryAsyncJobResult(cmd); |
| return createAsyncJobResponse(result); |
| } |
| |
| @Override |
| public SecurityGroupResponse createSecurityGroupResponseFromSecurityGroupRule(List<? extends SecurityRule> securityRules) { |
| SecurityGroupResponse response = new SecurityGroupResponse(); |
| Map<Long, Account> securiytGroupAccounts = new HashMap<Long, Account>(); |
| Map<Long, SecurityGroup> allowedSecurityGroups = new HashMap<Long, SecurityGroup>(); |
| Map<Long, Account> allowedSecuriytGroupAccounts = new HashMap<Long, Account>(); |
| |
| if ((securityRules != null) && !securityRules.isEmpty()) { |
| SecurityGroup securityGroup = ApiDBUtils.findSecurityGroupById(securityRules.get(0).getSecurityGroupId()); |
| response.setId(securityGroup.getId()); |
| response.setName(securityGroup.getName()); |
| response.setDescription(securityGroup.getDescription()); |
| |
| Account account = securiytGroupAccounts.get(securityGroup.getAccountId()); |
| |
| if (account == null) { |
| account = ApiDBUtils.findAccountById(securityGroup.getAccountId()); |
| securiytGroupAccounts.put(securityGroup.getAccountId(), account); |
| } |
| |
| populateAccount(response, account.getId()); |
| populateDomain(response, account.getDomainId()); |
| |
| List<SecurityGroupRuleResponse> egressResponses = new ArrayList<SecurityGroupRuleResponse>(); |
| List<SecurityGroupRuleResponse> ingressResponses = new ArrayList<SecurityGroupRuleResponse>(); |
| for (SecurityRule securityRule : securityRules) { |
| SecurityGroupRuleResponse securityGroupData = new SecurityGroupRuleResponse(); |
| |
| securityGroupData.setRuleId(securityRule.getId()); |
| securityGroupData.setProtocol(securityRule.getProtocol()); |
| if ("icmp".equalsIgnoreCase(securityRule.getProtocol())) { |
| securityGroupData.setIcmpType(securityRule.getStartPort()); |
| securityGroupData.setIcmpCode(securityRule.getEndPort()); |
| } else { |
| securityGroupData.setStartPort(securityRule.getStartPort()); |
| securityGroupData.setEndPort(securityRule.getEndPort()); |
| } |
| |
| Long allowedSecurityGroupId = securityRule.getAllowedNetworkId(); |
| if (allowedSecurityGroupId != null) { |
| SecurityGroup allowedSecurityGroup = allowedSecurityGroups.get(allowedSecurityGroupId); |
| if (allowedSecurityGroup == null) { |
| allowedSecurityGroup = ApiDBUtils.findSecurityGroupById(allowedSecurityGroupId); |
| allowedSecurityGroups.put(allowedSecurityGroupId, allowedSecurityGroup); |
| } |
| |
| securityGroupData.setSecurityGroupName(allowedSecurityGroup.getName()); |
| |
| Account allowedAccount = allowedSecuriytGroupAccounts.get(allowedSecurityGroup.getAccountId()); |
| if (allowedAccount == null) { |
| allowedAccount = ApiDBUtils.findAccountById(allowedSecurityGroup.getAccountId()); |
| allowedSecuriytGroupAccounts.put(allowedAccount.getId(), allowedAccount); |
| } |
| |
| securityGroupData.setAccountName(allowedAccount.getAccountName()); |
| } else { |
| securityGroupData.setCidr(securityRule.getAllowedSourceIpCidr()); |
| } |
| if (securityRule.getRuleType() == SecurityRuleType.IngressRule) { |
| securityGroupData.setObjectName("ingressrule"); |
| ingressResponses.add(securityGroupData); |
| } else { |
| securityGroupData.setObjectName("egressrule"); |
| egressResponses.add(securityGroupData); |
| } |
| |
| } |
| response.setSecurityGroupIngressRules(ingressResponses); |
| response.setSecurityGroupEgressRules(egressResponses); |
| response.setObjectName("securitygroup"); |
| |
| } |
| return response; |
| } |
| |
| @Override |
| public NetworkOfferingResponse createNetworkOfferingResponse(NetworkOffering offering) { |
| NetworkOfferingResponse response = new NetworkOfferingResponse(); |
| response.setId(offering.getId()); |
| response.setName(offering.getName()); |
| response.setDisplayText(offering.getDisplayText()); |
| response.setTags(offering.getTags()); |
| response.setTrafficType(offering.getTrafficType().toString()); |
| response.setIsDefault(offering.isDefault()); |
| response.setSpecifyVlan(offering.getSpecifyVlan()); |
| response.setConserveMode(offering.isConserveMode()); |
| response.setSpecifyIpRanges(offering.getSpecifyIpRanges()); |
| response.setAvailability(offering.getAvailability().toString()); |
| response.setNetworkRate(ApiDBUtils.getNetworkRate(offering.getId())); |
| if (offering.getServiceOfferingId() != null) { |
| response.setServiceOfferingId(offering.getServiceOfferingId()); |
| } else { |
| response.setServiceOfferingId(ApiDBUtils.findDefaultRouterServiceOffering()); |
| } |
| if (offering.getGuestType() != null) { |
| response.setGuestIpType(offering.getGuestType().toString()); |
| } |
| |
| response.setState(offering.getState().name()); |
| |
| Map<Service, Set<Provider>> serviceProviderMap = ApiDBUtils.listNetworkOfferingServices(offering.getId()); |
| List<ServiceResponse> serviceResponses = new ArrayList<ServiceResponse>(); |
| for (Service service : serviceProviderMap.keySet()) { |
| ServiceResponse svcRsp = new ServiceResponse(); |
| // skip gateway service |
| if (service == Service.Gateway) { |
| continue; |
| } |
| svcRsp.setName(service.getName()); |
| List<ProviderResponse> providers = new ArrayList<ProviderResponse>(); |
| for (Provider provider : serviceProviderMap.get(service)) { |
| if (provider != null) { |
| ProviderResponse providerRsp = new ProviderResponse(); |
| providerRsp.setName(provider.getName()); |
| providers.add(providerRsp); |
| } |
| } |
| svcRsp.setProviders(providers); |
| |
| if (Service.Lb == service) { |
| List<CapabilityResponse> lbCapResponse = new ArrayList<CapabilityResponse>(); |
| |
| CapabilityResponse lbIsoaltion = new CapabilityResponse(); |
| lbIsoaltion.setName(Capability.SupportedLBIsolation.getName()); |
| lbIsoaltion.setValue(offering.getDedicatedLB() ? "dedicated" : "shared"); |
| lbCapResponse.add(lbIsoaltion); |
| |
| CapabilityResponse eLb = new CapabilityResponse(); |
| eLb.setName(Capability.ElasticLb.getName()); |
| eLb.setValue(offering.getElasticLb() ? "true" : "false"); |
| lbCapResponse.add(eLb); |
| |
| svcRsp.setCapabilities(lbCapResponse); |
| } else if (Service.SourceNat == service) { |
| List<CapabilityResponse> capabilities = new ArrayList<CapabilityResponse>(); |
| CapabilityResponse sharedSourceNat = new CapabilityResponse(); |
| sharedSourceNat.setName(Capability.SupportedSourceNatTypes.getName()); |
| sharedSourceNat.setValue(offering.getSharedSourceNat() ? "perzone" : "peraccount"); |
| capabilities.add(sharedSourceNat); |
| |
| CapabilityResponse redundantRouter = new CapabilityResponse(); |
| redundantRouter.setName(Capability.RedundantRouter.getName()); |
| redundantRouter.setValue(offering.getRedundantRouter() ? "true" : "false"); |
| capabilities.add(redundantRouter); |
| |
| svcRsp.setCapabilities(capabilities); |
| } else if (service == Service.StaticNat) { |
| List<CapabilityResponse> staticNatCapResponse = new ArrayList<CapabilityResponse>(); |
| |
| CapabilityResponse eIp = new CapabilityResponse(); |
| eIp.setName(Capability.ElasticIp.getName()); |
| eIp.setValue(offering.getElasticLb() ? "true" : "false"); |
| staticNatCapResponse.add(eIp); |
| |
| svcRsp.setCapabilities(staticNatCapResponse); |
| } |
| |
| serviceResponses.add(svcRsp); |
| } |
| response.setForVpc(ApiDBUtils.isOfferingForVpc(offering)); |
| |
| response.setServices(serviceResponses); |
| response.setObjectName("networkoffering"); |
| return response; |
| } |
| |
| @Override |
| public NetworkResponse createNetworkResponse(Network network) { |
| // need to get network profile in order to retrieve dns information from there |
| NetworkProfile profile = ApiDBUtils.getNetworkProfile(network.getId()); |
| NetworkResponse response = new NetworkResponse(); |
| response.setId(network.getId()); |
| response.setName(network.getName()); |
| response.setDisplaytext(network.getDisplayText()); |
| if (network.getBroadcastDomainType() != null) { |
| response.setBroadcastDomainType(network.getBroadcastDomainType().toString()); |
| } |
| |
| if (network.getTrafficType() != null) { |
| response.setTrafficType(network.getTrafficType().name()); |
| } |
| |
| if (network.getGuestType() != null) { |
| response.setType(network.getGuestType().toString()); |
| } |
| |
| response.setGateway(network.getGateway()); |
| |
| // FIXME - either set netmask or cidr |
| response.setCidr(network.getCidr()); |
| if (network.getCidr() != null) { |
| response.setNetmask(NetUtils.cidr2Netmask(network.getCidr())); |
| } |
| |
| response.setIp6Gateway(network.getIp6Gateway()); |
| response.setIp6Cidr(network.getIp6Cidr()); |
| |
| //return vlan information only to Root admin |
| if (network.getBroadcastUri() != null && UserContext.current().getCaller().getType() == Account.ACCOUNT_TYPE_ADMIN) { |
| String broadcastUri = network.getBroadcastUri().toString(); |
| response.setBroadcastUri(broadcastUri); |
| String vlan="N/A"; |
| if (broadcastUri.startsWith("vlan")) { |
| vlan = broadcastUri.substring("vlan://".length(), broadcastUri.length()); |
| } |
| //return vlan information only to Root admin |
| response.setVlan(vlan); |
| |
| } |
| |
| DataCenter zone = ApiDBUtils.findZoneById(network.getDataCenterId()); |
| response.setZoneId(network.getDataCenterId()); |
| response.setZoneName(zone.getName()); |
| response.setPhysicalNetworkId(network.getPhysicalNetworkId()); |
| |
| // populate network offering information |
| NetworkOffering networkOffering = ApiDBUtils.findNetworkOfferingById(network.getNetworkOfferingId()); |
| if (networkOffering != null) { |
| response.setNetworkOfferingId(networkOffering.getId()); |
| response.setNetworkOfferingName(networkOffering.getName()); |
| response.setNetworkOfferingDisplayText(networkOffering.getDisplayText()); |
| response.setIsSystem(networkOffering.isSystemOnly()); |
| response.setNetworkOfferingAvailability(networkOffering.getAvailability().toString()); |
| } |
| |
| if (network.getAclType() != null) { |
| response.setAclType(network.getAclType().toString()); |
| } |
| response.setState(network.getState().toString()); |
| response.setRestartRequired(network.isRestartRequired()); |
| response.setRelated(network.getRelated()); |
| response.setNetworkDomain(network.getNetworkDomain()); |
| |
| response.setDns1(profile.getDns1()); |
| response.setDns2(profile.getDns2()); |
| // populate capability |
| Map<Service, Map<Capability, String>> serviceCapabilitiesMap = ApiDBUtils.getNetworkCapabilities(network.getId(), network.getDataCenterId()); |
| List<ServiceResponse> serviceResponses = new ArrayList<ServiceResponse>(); |
| if (serviceCapabilitiesMap != null) { |
| for (Service service : serviceCapabilitiesMap.keySet()) { |
| ServiceResponse serviceResponse = new ServiceResponse(); |
| // skip gateway service |
| if (service == Service.Gateway) { |
| continue; |
| } |
| serviceResponse.setName(service.getName()); |
| |
| // set list of capabilities for the service |
| List<CapabilityResponse> capabilityResponses = new ArrayList<CapabilityResponse>(); |
| Map<Capability, String> serviceCapabilities = serviceCapabilitiesMap.get(service); |
| if (serviceCapabilities != null) { |
| for (Capability capability : serviceCapabilities.keySet()) { |
| CapabilityResponse capabilityResponse = new CapabilityResponse(); |
| String capabilityValue = serviceCapabilities.get(capability); |
| capabilityResponse.setName(capability.getName()); |
| capabilityResponse.setValue(capabilityValue); |
| capabilityResponse.setObjectName("capability"); |
| capabilityResponses.add(capabilityResponse); |
| } |
| serviceResponse.setCapabilities(capabilityResponses); |
| } |
| |
| serviceResponse.setObjectName("service"); |
| serviceResponses.add(serviceResponse); |
| } |
| } |
| response.setServices(serviceResponses); |
| |
| if (network.getAclType() == null || network.getAclType() == ACLType.Account) { |
| populateOwner(response, network); |
| } else { |
| // get domain from network_domain table |
| Pair<Long, Boolean> domainNetworkDetails = ApiDBUtils.getDomainNetworkDetails(network.getId()); |
| response.setDomainId(domainNetworkDetails.first()); |
| response.setSubdomainAccess(domainNetworkDetails.second()); |
| } |
| |
| Long dedicatedDomainId = ApiDBUtils.getDedicatedNetworkDomain(network.getId()); |
| if (dedicatedDomainId != null) { |
| Domain domain = ApiDBUtils.findDomainById(dedicatedDomainId); |
| response.setDomainId(dedicatedDomainId); |
| response.setDomainName(domain.getName()); |
| } |
| |
| response.setSpecifyIpRanges(network.getSpecifyIpRanges()); |
| response.setVpcId(network.getVpcId()); |
| response.setCanUseForDeploy(ApiDBUtils.canUseForDeploy(network)); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.Network, network.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| response.setTags(tagResponses); |
| |
| response.setObjectName("network"); |
| return response; |
| } |
| |
| @Override |
| public Long getSecurityGroupId(String groupName, long accountId) { |
| SecurityGroup sg = ApiDBUtils.getSecurityGroup(groupName, accountId); |
| if (sg == null) { |
| return null; |
| } else { |
| return sg.getId(); |
| } |
| } |
| |
| @Override |
| public ProjectResponse createProjectResponse(Project project) { |
| ProjectResponse response = new ProjectResponse(); |
| response.setId(project.getId()); |
| response.setName(project.getName()); |
| response.setDisplaytext(project.getDisplayText()); |
| response.setState(project.getState().toString()); |
| |
| Domain domain = ApiDBUtils.findDomainById(project.getDomainId()); |
| response.setDomainId(domain.getId()); |
| response.setDomain(domain.getName()); |
| |
| response.setOwner(ApiDBUtils.getProjectOwner(project.getId()).getAccountName()); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.Project, project.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| response.setTags(tagResponses); |
| |
| response.setObjectName("project"); |
| return response; |
| } |
| |
| @Override |
| public FirewallResponse createFirewallResponse(FirewallRule fwRule) { |
| FirewallResponse response = new FirewallResponse(); |
| |
| response.setId(fwRule.getId()); |
| response.setProtocol(fwRule.getProtocol()); |
| if (fwRule.getSourcePortStart() != null) { |
| response.setStartPort(Integer.toString(fwRule.getSourcePortStart())); |
| } |
| |
| if (fwRule.getSourcePortEnd() != null) { |
| response.setEndPort(Integer.toString(fwRule.getSourcePortEnd())); |
| } |
| |
| List<String> cidrs = ApiDBUtils.findFirewallSourceCidrs(fwRule.getId()); |
| response.setCidrList(StringUtils.join(cidrs, ",")); |
| |
| IpAddress ip = ApiDBUtils.findIpAddressById(fwRule.getSourceIpAddressId()); |
| response.setPublicIpAddressId(ip.getId()); |
| response.setPublicIpAddress(ip.getAddress().addr()); |
| |
| FirewallRule.State state = fwRule.getState(); |
| String stateToSet = state.toString(); |
| if (state.equals(FirewallRule.State.Revoke)) { |
| stateToSet = "Deleting"; |
| } |
| |
| response.setIcmpCode(fwRule.getIcmpCode()); |
| response.setIcmpType(fwRule.getIcmpType()); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.FirewallRule, fwRule.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| response.setTags(tagResponses); |
| |
| response.setState(stateToSet); |
| response.setObjectName("firewallrule"); |
| return response; |
| } |
| |
| @Override |
| public NetworkACLResponse createNetworkACLResponse(FirewallRule networkACL) { |
| NetworkACLResponse response = new NetworkACLResponse(); |
| |
| response.setId(networkACL.getId()); |
| response.setProtocol(networkACL.getProtocol()); |
| if (networkACL.getSourcePortStart() != null) { |
| response.setStartPort(Integer.toString(networkACL.getSourcePortStart())); |
| } |
| |
| if (networkACL.getSourcePortEnd() != null) { |
| response.setEndPort(Integer.toString(networkACL.getSourcePortEnd())); |
| } |
| |
| List<String> cidrs = ApiDBUtils.findFirewallSourceCidrs(networkACL.getId()); |
| response.setCidrList(StringUtils.join(cidrs, ",")); |
| |
| response.setTrafficType(networkACL.getTrafficType().toString()); |
| |
| FirewallRule.State state = networkACL.getState(); |
| String stateToSet = state.toString(); |
| if (state.equals(FirewallRule.State.Revoke)) { |
| stateToSet = "Deleting"; |
| } |
| |
| response.setIcmpCode(networkACL.getIcmpCode()); |
| response.setIcmpType(networkACL.getIcmpType()); |
| |
| response.setState(stateToSet); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.NetworkACL, networkACL.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| response.setTags(tagResponses); |
| |
| response.setObjectName("networkacl"); |
| return response; |
| } |
| |
| public UserVmData newUserVmData(UserVm userVm) { |
| UserVmData userVmData = new UserVmData(); |
| userVmData.setId(userVm.getId()); |
| userVmData.setName(userVm.getHostName()); |
| userVmData.setCreated(userVm.getCreated()); |
| userVmData.setGuestOsId(userVm.getGuestOSId()); |
| userVmData.setHaEnable(userVm.isHaEnabled()); |
| if (userVm.getState() != null) { |
| userVmData.setState(userVm.getState().toString()); |
| } |
| if (userVm.getDisplayName() != null) { |
| userVmData.setDisplayName(userVm.getDisplayName()); |
| } else { |
| userVmData.setDisplayName(userVm.getHostName()); |
| } |
| userVmData.setInstanceName(userVm.getInstanceName()); |
| |
| userVmData.setDomainId(userVm.getDomainId()); |
| |
| if (userVm.getHypervisorType() != null) { |
| userVmData.setHypervisor(userVm.getHypervisorType().toString()); |
| } |
| |
| if (userVm.getPassword() != null) { |
| userVmData.setPassword(userVm.getPassword()); |
| } |
| return userVmData; |
| } |
| |
| public UserVmResponse newUserVmResponse(UserVmData userVmData, boolean caller_is_admin) { |
| UserVmResponse userVmResponse = new UserVmResponse(); |
| |
| userVmResponse.setHypervisor(userVmData.getHypervisor()); |
| userVmResponse.setId(userVmData.getId()); |
| userVmResponse.setName(userVmData.getName()); |
| |
| userVmResponse.setDisplayName(userVmData.getDisplayName()); |
| |
| populateAccount(userVmResponse, userVmData.getAccountId()); |
| populateDomain(userVmResponse, userVmData.getDomainId()); |
| |
| userVmResponse.setCreated(userVmData.getCreated()); |
| userVmResponse.setState(userVmData.getState()); |
| userVmResponse.setHaEnable(userVmData.getHaEnable()); |
| userVmResponse.setGroupId(userVmData.getGroupId()); |
| userVmResponse.setGroup(userVmData.getGroup()); |
| userVmResponse.setZoneId(userVmData.getZoneId()); |
| userVmResponse.setZoneName(userVmData.getZoneName()); |
| if (caller_is_admin) { |
| userVmResponse.setInstanceName(userVmData.getInstanceName()); |
| userVmResponse.setHostId(userVmData.getHostId()); |
| userVmResponse.setHostName(userVmData.getHostName()); |
| } |
| userVmResponse.setTemplateId(userVmData.getTemplateId()); |
| userVmResponse.setTemplateName(userVmData.getTemplateName()); |
| userVmResponse.setTemplateDisplayText(userVmData.getTemplateDisplayText()); |
| userVmResponse.setPasswordEnabled(userVmData.getPasswordEnabled()); |
| userVmResponse.setIsoId(userVmData.getIsoId()); |
| userVmResponse.setIsoName(userVmData.getIsoName()); |
| userVmResponse.setIsoDisplayText(userVmData.getIsoDisplayText()); |
| userVmResponse.setServiceOfferingId(userVmData.getServiceOfferingId()); |
| userVmResponse.setServiceOfferingName(userVmData.getServiceOfferingName()); |
| userVmResponse.setCpuNumber(userVmData.getCpuNumber()); |
| userVmResponse.setCpuSpeed(userVmData.getCpuSpeed()); |
| userVmResponse.setMemory(userVmData.getMemory()); |
| userVmResponse.setCpuUsed(userVmData.getCpuUsed()); |
| userVmResponse.setNetworkKbsRead(userVmData.getNetworkKbsRead()); |
| userVmResponse.setNetworkKbsWrite(userVmData.getNetworkKbsWrite()); |
| userVmResponse.setGuestOsId(userVmData.getGuestOsId()); |
| userVmResponse.setRootDeviceId(userVmData.getRootDeviceId()); |
| userVmResponse.setRootDeviceType(userVmData.getRootDeviceType()); |
| userVmResponse.setPassword(userVmData.getPassword()); |
| userVmResponse.setJobId(userVmData.getJobId()); |
| userVmResponse.setJobStatus(userVmData.getJobStatus()); |
| userVmResponse.setForVirtualNetwork(userVmData.getForVirtualNetwork()); |
| |
| Set<SecurityGroupResponse> securityGroupResponse = new HashSet<SecurityGroupResponse>(); |
| for (SecurityGroupData sgd : userVmData.getSecurityGroupList()) { |
| if (sgd.getId() != null) { |
| SecurityGroupResponse sgr = new SecurityGroupResponse(); |
| sgr.setId(sgd.getId()); |
| sgr.setName(sgd.getName()); |
| sgr.setDescription(sgd.getDescription()); |
| |
| Account account = ApiDBUtils.findAccountByNameDomain(sgd.getAccountName(), sgd.getDomainId()); |
| if (account != null) { |
| populateAccount(sgr, account.getId()); |
| populateDomain(sgr, account.getDomainId()); |
| } |
| |
| sgr.setObjectName(sgd.getObjectName()); |
| securityGroupResponse.add(sgr); |
| } |
| } |
| userVmResponse.setSecurityGroupList(new ArrayList<SecurityGroupResponse>(securityGroupResponse)); |
| |
| Set<NicResponse> nicResponses = new HashSet<NicResponse>(); |
| for (NicData nd : userVmData.getNics()) { |
| NicResponse nr = new NicResponse(); |
| nr.setId(nd.getId()); |
| nr.setNetworkid(nd.getNetworkid()); |
| nr.setNetmask(nd.getNetmask()); |
| nr.setGateway(nd.getGateway()); |
| nr.setIpaddress(nd.getIpaddress()); |
| nr.setIp6Address(nd.getIp6Address()); |
| nr.setIp6Gateway(nd.getIp6Gateway()); |
| nr.setIp6Cidr(nd.getIp6Cidr()); |
| nr.setIsolationUri(nd.getIsolationUri()); |
| nr.setBroadcastUri(nd.getBroadcastUri()); |
| nr.setTrafficType(nd.getTrafficType()); |
| nr.setType(nd.getType()); |
| nr.setIsDefault(nd.getIsDefault()); |
| nr.setMacAddress(nd.getMacAddress()); |
| nr.setObjectName(nd.getObjectName()); |
| nicResponses.add(nr); |
| } |
| userVmResponse.setNics(new ArrayList<NicResponse>(nicResponses)); |
| userVmResponse.setPublicIpId(userVmData.getPublicIpId()); |
| userVmResponse.setPublicIp(userVmData.getPublicIp()); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.UserVm, userVmData.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| userVmResponse.setTags(tagResponses); |
| |
| UserVmDetailVO userVmDetail = ApiDBUtils.findPublicKeyByVmId(userVmData.getId()); |
| if (userVmDetail != null && userVmDetail.getValue() != null) { |
| String keyPairName = ApiDBUtils.getKeyPairName(userVmDetail.getValue()); |
| userVmResponse.setKeyPairName(keyPairName); |
| } |
| |
| return userVmResponse; |
| } |
| |
| @Override |
| public HypervisorCapabilitiesResponse createHypervisorCapabilitiesResponse(HypervisorCapabilities hpvCapabilities) { |
| HypervisorCapabilitiesResponse hpvCapabilitiesResponse = new HypervisorCapabilitiesResponse(); |
| hpvCapabilitiesResponse.setId(hpvCapabilities.getId()); |
| hpvCapabilitiesResponse.setHypervisor(hpvCapabilities.getHypervisorType()); |
| hpvCapabilitiesResponse.setHypervisorVersion(hpvCapabilities.getHypervisorVersion()); |
| hpvCapabilitiesResponse.setIsSecurityGroupEnabled(hpvCapabilities.isSecurityGroupEnabled()); |
| hpvCapabilitiesResponse.setMaxGuestsLimit(hpvCapabilities.getMaxGuestsLimit()); |
| return hpvCapabilitiesResponse; |
| } |
| |
| private void populateOwner(ControlledEntityResponse response, ControlledEntity object) { |
| Account account = ApiDBUtils.findAccountByIdIncludingRemoved(object.getAccountId()); |
| |
| if (account.getType() == Account.ACCOUNT_TYPE_PROJECT) { |
| // find the project |
| Project project = ApiDBUtils.findProjectByProjectAccountIdIncludingRemoved(account.getId()); |
| response.setProjectId(project.getId()); |
| response.setProjectName(project.getName()); |
| } else { |
| response.setAccountName(account.getAccountName()); |
| } |
| |
| Domain domain = ApiDBUtils.findDomainById(object.getDomainId()); |
| response.setDomainId(domain.getId()); |
| response.setDomainName(domain.getName()); |
| } |
| |
| private void populateAccount(ControlledEntityResponse response, long accountId) { |
| Account account = ApiDBUtils.findAccountByIdIncludingRemoved(accountId); |
| if (account.getType() == Account.ACCOUNT_TYPE_PROJECT) { |
| // find the project |
| Project project = ApiDBUtils.findProjectByProjectAccountIdIncludingRemoved(account.getId()); |
| response.setProjectId(project.getId()); |
| response.setProjectName(project.getName()); |
| } else { |
| response.setAccountName(account.getAccountName()); |
| } |
| } |
| |
| private void populateDomain(ControlledEntityResponse response, long domainId) { |
| Domain domain = ApiDBUtils.findDomainById(domainId); |
| |
| response.setDomainId(domain.getId()); |
| response.setDomainName(domain.getName()); |
| } |
| |
| @Override |
| public ProjectAccountResponse createProjectAccountResponse(ProjectAccount projectAccount) { |
| Account account = ApiDBUtils.findAccountById(projectAccount.getAccountId()); |
| ProjectAccountResponse projectAccountResponse = new ProjectAccountResponse(); |
| |
| long projectId = projectAccount.getProjectId(); |
| projectAccountResponse.setProjectId(projectId); |
| projectAccountResponse.setProjectName(ApiDBUtils.findProjectById(projectId).getName()); |
| |
| projectAccountResponse.setId(account.getId()); |
| projectAccountResponse.setAccountName(account.getAccountName()); |
| projectAccountResponse.setAccountType(account.getType()); |
| projectAccountResponse.setRole(projectAccount.getAccountRole().toString()); |
| populateDomain(projectAccountResponse, account.getDomainId()); |
| |
| // add all the users for an account as part of the response obj |
| List<UserVO> usersForAccount = ApiDBUtils.listUsersByAccount(account.getAccountId()); |
| List<UserResponse> userResponseList = new ArrayList<UserResponse>(); |
| for (UserVO user : usersForAccount) { |
| UserResponse userResponse = createUserResponse(user); |
| userResponseList.add(userResponse); |
| } |
| |
| projectAccountResponse.setUsers(userResponseList); |
| projectAccountResponse.setObjectName("projectaccount"); |
| |
| return projectAccountResponse; |
| } |
| |
| @Override |
| public ProjectInvitationResponse createProjectInvitationResponse(ProjectInvitation invite) { |
| ProjectInvitationResponse response = new ProjectInvitationResponse(); |
| response.setId(invite.getId()); |
| response.setProjectId(invite.getProjectId()); |
| response.setProjectName(ApiDBUtils.findProjectById(invite.getProjectId()).getName()); |
| response.setInvitationState(invite.getState().toString()); |
| |
| if (invite.getForAccountId() != null) { |
| Account account = ApiDBUtils.findAccountById(invite.getForAccountId()); |
| response.setAccountName(account.getAccountName()); |
| |
| } else { |
| response.setEmail(invite.getEmail()); |
| } |
| |
| populateDomain(response, invite.getInDomainId()); |
| |
| response.setObjectName("projectinvitation"); |
| return response; |
| } |
| |
| @Override |
| public SystemVmInstanceResponse createSystemVmInstanceResponse(VirtualMachine vm) { |
| SystemVmInstanceResponse vmResponse = new SystemVmInstanceResponse(); |
| vmResponse.setId(vm.getId()); |
| vmResponse.setSystemVmType(vm.getType().toString().toLowerCase()); |
| vmResponse.setName(vm.getHostName()); |
| if (vm.getHostId() != null) { |
| vmResponse.setHostId(vm.getHostId()); |
| } |
| if (vm.getState() != null) { |
| vmResponse.setState(vm.getState().toString()); |
| } |
| if (vm.getType() == Type.DomainRouter) { |
| VirtualRouter router = (VirtualRouter) vm; |
| if (router.getRole() != null) { |
| vmResponse.setRole(router.getRole().toString()); |
| } |
| } |
| vmResponse.setObjectName("systemvminstance"); |
| return vmResponse; |
| } |
| |
| @Override |
| public PhysicalNetworkResponse createPhysicalNetworkResponse(PhysicalNetwork result) { |
| PhysicalNetworkResponse response = new PhysicalNetworkResponse(); |
| |
| response.setZoneId(result.getDataCenterId()); |
| response.setNetworkSpeed(result.getSpeed()); |
| response.setVlan(result.getVnet()); |
| response.setDomainId(result.getDomainId()); |
| response.setId(result.getUuid()); |
| if (result.getBroadcastDomainRange() != null) { |
| response.setBroadcastDomainRange(result.getBroadcastDomainRange().toString()); |
| } |
| response.setIsolationMethods(result.getIsolationMethods()); |
| response.setTags(result.getTags()); |
| if (result.getState() != null) { |
| response.setState(result.getState().toString()); |
| } |
| |
| response.setName(result.getName()); |
| |
| response.setObjectName("physicalnetwork"); |
| return response; |
| } |
| |
| @Override |
| public ServiceResponse createNetworkServiceResponse(Service service) { |
| ServiceResponse response = new ServiceResponse(); |
| response.setName(service.getName()); |
| |
| // set list of capabilities required for the service |
| List<CapabilityResponse> capabilityResponses = new ArrayList<CapabilityResponse>(); |
| Capability[] capabilities = service.getCapabilities(); |
| for (Capability cap : capabilities) { |
| CapabilityResponse capabilityResponse = new CapabilityResponse(); |
| capabilityResponse.setName(cap.getName()); |
| capabilityResponse.setObjectName("capability"); |
| if (cap.getName().equals(Capability.SupportedLBIsolation.getName()) || |
| cap.getName().equals(Capability.SupportedSourceNatTypes.getName()) || |
| cap.getName().equals(Capability.RedundantRouter.getName())) { |
| capabilityResponse.setCanChoose(true); |
| } else { |
| capabilityResponse.setCanChoose(false); |
| } |
| capabilityResponses.add(capabilityResponse); |
| } |
| response.setCapabilities(capabilityResponses); |
| |
| // set list of providers providing this service |
| List<? extends Network.Provider> serviceProviders = ApiDBUtils.getProvidersForService(service); |
| List<ProviderResponse> serviceProvidersResponses = new ArrayList<ProviderResponse>(); |
| for (Network.Provider serviceProvider : serviceProviders) { |
| // return only Virtual Router/JuniperSRX as a provider for the firewall |
| if (service == Service.Firewall && !(serviceProvider == Provider.VirtualRouter || serviceProvider == Provider.JuniperSRX)) { |
| continue; |
| } |
| |
| ProviderResponse serviceProviderResponse = createServiceProviderResponse(serviceProvider); |
| serviceProvidersResponses.add(serviceProviderResponse); |
| } |
| response.setProviders(serviceProvidersResponses); |
| |
| response.setObjectName("networkservice"); |
| return response; |
| |
| } |
| |
| private ProviderResponse createServiceProviderResponse(Provider serviceProvider) { |
| ProviderResponse response = new ProviderResponse(); |
| response.setName(serviceProvider.getName()); |
| boolean canEnableIndividualServices = ApiDBUtils.canElementEnableIndividualServices(serviceProvider); |
| response.setCanEnableIndividualServices(canEnableIndividualServices); |
| return response; |
| } |
| |
| @Override |
| public ProviderResponse createNetworkServiceProviderResponse(PhysicalNetworkServiceProvider result) { |
| ProviderResponse response = new ProviderResponse(); |
| response.setId(result.getUuid()); |
| response.setName(result.getProviderName()); |
| response.setPhysicalNetworkId(result.getPhysicalNetworkId()); |
| response.setDestinationPhysicalNetworkId(result.getDestinationPhysicalNetworkId()); |
| response.setState(result.getState().toString()); |
| |
| // set enabled services |
| List<String> services = new ArrayList<String>(); |
| for (Service service : result.getEnabledServices()) { |
| services.add(service.getName()); |
| } |
| response.setServices(services); |
| |
| response.setObjectName("networkserviceprovider"); |
| return response; |
| } |
| |
| @Override |
| public TrafficTypeResponse createTrafficTypeResponse(PhysicalNetworkTrafficType result) { |
| TrafficTypeResponse response = new TrafficTypeResponse(); |
| response.setId(result.getUuid()); |
| response.setPhysicalNetworkId(result.getPhysicalNetworkId()); |
| response.setTrafficType(result.getTrafficType().toString()); |
| response.setXenLabel(result.getXenNetworkLabel()); |
| response.setKvmLabel(result.getKvmNetworkLabel()); |
| response.setVmwareLabel(result.getVmwareNetworkLabel()); |
| |
| response.setObjectName("traffictype"); |
| return response; |
| } |
| |
| @Override |
| public VirtualRouterProviderResponse createVirtualRouterProviderResponse(VirtualRouterProvider result) { |
| VirtualRouterProviderResponse response = new VirtualRouterProviderResponse(); |
| response.setId(result.getId()); |
| response.setNspId(result.getNspId()); |
| response.setEnabled(result.isEnabled()); |
| |
| response.setObjectName("virtualrouterelement"); |
| return response; |
| } |
| |
| @Override |
| public LBStickinessResponse createLBStickinessPolicyResponse( |
| StickinessPolicy stickinessPolicy, LoadBalancer lb) { |
| LBStickinessResponse spResponse = new LBStickinessResponse(); |
| |
| spResponse.setlbRuleId(lb.getId()); |
| Account accountTemp = ApiDBUtils.findAccountById(lb.getAccountId()); |
| if (accountTemp != null) { |
| spResponse.setAccountName(accountTemp.getAccountName()); |
| spResponse.setDomainId(accountTemp.getDomainId()); |
| spResponse.setDomainName(ApiDBUtils.findDomainById( |
| accountTemp.getDomainId()).getName()); |
| } |
| |
| List<LBStickinessPolicyResponse> responses = new ArrayList<LBStickinessPolicyResponse>(); |
| LBStickinessPolicyResponse ruleResponse = new LBStickinessPolicyResponse( |
| stickinessPolicy); |
| responses.add(ruleResponse); |
| |
| spResponse.setRules(responses); |
| |
| spResponse.setObjectName("stickinesspolicies"); |
| return spResponse; |
| } |
| |
| @Override |
| public LBStickinessResponse createLBStickinessPolicyResponse( |
| List<? extends StickinessPolicy> stickinessPolicies, LoadBalancer lb) { |
| LBStickinessResponse spResponse = new LBStickinessResponse(); |
| |
| if (lb == null) |
| return spResponse; |
| spResponse.setlbRuleId(lb.getId()); |
| Account account = ApiDBUtils.findAccountById(lb.getAccountId()); |
| if (account != null) { |
| spResponse.setAccountName(account.getAccountName()); |
| spResponse.setDomainId(account.getDomainId()); |
| spResponse.setDomainName(ApiDBUtils.findDomainById( |
| account.getDomainId()).getName()); |
| } |
| |
| List<LBStickinessPolicyResponse> responses = new ArrayList<LBStickinessPolicyResponse>(); |
| for (StickinessPolicy stickinessPolicy : stickinessPolicies) { |
| LBStickinessPolicyResponse ruleResponse = new LBStickinessPolicyResponse(stickinessPolicy); |
| responses.add(ruleResponse); |
| } |
| spResponse.setRules(responses); |
| |
| spResponse.setObjectName("stickinesspolicies"); |
| return spResponse; |
| } |
| |
| @Override |
| public LDAPConfigResponse createLDAPConfigResponse(String hostname, |
| Integer port, Boolean useSSL, String queryFilter, |
| String searchBase, String bindDN) { |
| LDAPConfigResponse lr = new LDAPConfigResponse(); |
| lr.setHostname(hostname); |
| lr.setPort(port.toString()); |
| lr.setUseSSL(useSSL.toString()); |
| lr.setQueryFilter(queryFilter); |
| lr.setBindDN(bindDN); |
| lr.setSearchBase(searchBase); |
| lr.setObjectName("ldapconfig"); |
| return lr; |
| } |
| |
| @Override |
| public StorageNetworkIpRangeResponse createStorageNetworkIpRangeResponse(StorageNetworkIpRange result) { |
| StorageNetworkIpRangeResponse response = new StorageNetworkIpRangeResponse(); |
| response.setUuid(result.getUuid()); |
| response.setVlan(result.getVlan()); |
| response.setEndIp(result.getEndIp()); |
| response.setStartIp(result.getStartIp()); |
| response.setPodUuid(result.getPodUuid()); |
| response.setZoneUuid(result.getZoneUuid()); |
| response.setNetworkUuid(result.getNetworkUuid()); |
| response.setNetmask(result.getNetmask()); |
| response.setGateway(result.getGateway()); |
| response.setObjectName("storagenetworkiprange"); |
| return response; |
| } |
| |
| @Override |
| public Long getIdentiyId(String tableName, String token) { |
| return ApiDispatcher.getIdentiyId(tableName, token); |
| } |
| |
| @Override |
| public ResourceTagResponse createResourceTagResponse(ResourceTag resourceTag, boolean keyValueOnly) { |
| ResourceTagResponse response = new ResourceTagResponse(); |
| response.setKey(resourceTag.getKey()); |
| response.setValue(resourceTag.getValue()); |
| |
| if (!keyValueOnly) { |
| response.setResourceType(resourceTag.getResourceType().toString()); |
| response.setId(ApiDBUtils.getUuid(String.valueOf(resourceTag.getResourceId()),resourceTag.getResourceType())); |
| Long accountId = resourceTag.getAccountId(); |
| Long domainId = resourceTag.getDomainId(); |
| if (accountId != null) { |
| Account account = ApiDBUtils.findAccountByIdIncludingRemoved(resourceTag.getAccountId()); |
| |
| if (account.getType() == Account.ACCOUNT_TYPE_PROJECT) { |
| // find the project |
| Project project = ApiDBUtils.findProjectByProjectAccountIdIncludingRemoved(account.getId()); |
| response.setProjectId(project.getId()); |
| response.setProjectName(project.getName()); |
| } else { |
| response.setAccountName(account.getAccountName()); |
| } |
| } |
| |
| if (domainId != null) { |
| response.setDomainId(domainId); |
| response.setDomainName(ApiDBUtils.findDomainById(domainId).getName()); |
| } |
| |
| response.setCustomer(resourceTag.getCustomer()); |
| } |
| |
| response.setObjectName("ag"); |
| |
| return response; |
| } |
| |
| @Override |
| public VpcOfferingResponse createVpcOfferingResponse(VpcOffering offering) { |
| VpcOfferingResponse response = new VpcOfferingResponse(); |
| response.setId(offering.getId()); |
| response.setName(offering.getName()); |
| response.setDisplayText(offering.getDisplayText()); |
| response.setIsDefault(offering.isDefault()); |
| response.setState(offering.getState().name()); |
| |
| Map<Service, Set<Provider>> serviceProviderMap = ApiDBUtils.listVpcOffServices(offering.getId()); |
| List<ServiceResponse> serviceResponses = new ArrayList<ServiceResponse>(); |
| for (Service service : serviceProviderMap.keySet()) { |
| ServiceResponse svcRsp = new ServiceResponse(); |
| // skip gateway service |
| if (service == Service.Gateway) { |
| continue; |
| } |
| svcRsp.setName(service.getName()); |
| List<ProviderResponse> providers = new ArrayList<ProviderResponse>(); |
| for (Provider provider : serviceProviderMap.get(service)) { |
| if (provider != null) { |
| ProviderResponse providerRsp = new ProviderResponse(); |
| providerRsp.setName(provider.getName()); |
| providers.add(providerRsp); |
| } |
| } |
| svcRsp.setProviders(providers); |
| |
| serviceResponses.add(svcRsp); |
| } |
| response.setServices(serviceResponses); |
| response.setObjectName("vpcoffering"); |
| return response; |
| } |
| |
| |
| @Override |
| public VpcResponse createVpcResponse(Vpc vpc) { |
| VpcResponse response = new VpcResponse(); |
| response.setId(vpc.getId()); |
| response.setName(vpc.getName()); |
| response.setDisplayText(vpc.getDisplayText()); |
| response.setState(vpc.getState().name()); |
| response.setVpcOfferingId(vpc.getVpcOfferingId()); |
| response.setCidr(vpc.getCidr()); |
| response.setRestartRequired(vpc.isRestartRequired()); |
| response.setNetworkDomain(vpc.getNetworkDomain()); |
| |
| Map<Service, Set<Provider>> serviceProviderMap = ApiDBUtils.listVpcOffServices(vpc.getVpcOfferingId()); |
| List<ServiceResponse> serviceResponses = new ArrayList<ServiceResponse>(); |
| for (Service service : serviceProviderMap.keySet()) { |
| ServiceResponse svcRsp = new ServiceResponse(); |
| // skip gateway service |
| if (service == Service.Gateway) { |
| continue; |
| } |
| svcRsp.setName(service.getName()); |
| List<ProviderResponse> providers = new ArrayList<ProviderResponse>(); |
| for (Provider provider : serviceProviderMap.get(service)) { |
| if (provider != null) { |
| ProviderResponse providerRsp = new ProviderResponse(); |
| providerRsp.setName(provider.getName()); |
| providers.add(providerRsp); |
| } |
| } |
| svcRsp.setProviders(providers); |
| |
| serviceResponses.add(svcRsp); |
| } |
| |
| List<NetworkResponse> networkResponses = new ArrayList<NetworkResponse>(); |
| List<? extends Network> networks = ApiDBUtils.listVpcNetworks(vpc.getId()); |
| for (Network network : networks) { |
| NetworkResponse ntwkRsp = createNetworkResponse(network); |
| networkResponses.add(ntwkRsp); |
| } |
| |
| DataCenter zone = ApiDBUtils.findZoneById(vpc.getZoneId()); |
| response.setZoneId(vpc.getZoneId()); |
| response.setZoneName(zone.getName()); |
| |
| response.setNetworks(networkResponses); |
| response.setServices(serviceResponses); |
| populateOwner(response, vpc); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.Vpc, vpc.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| response.setTags(tagResponses); |
| response.setObjectName("vpc"); |
| return response; |
| } |
| |
| @Override |
| public PrivateGatewayResponse createPrivateGatewayResponse(PrivateGateway result) { |
| PrivateGatewayResponse response = new PrivateGatewayResponse(); |
| response.setId(result.getId()); |
| response.setVlan(result.getVlanTag()); |
| response.setGateway(result.getGateway()); |
| response.setNetmask(result.getNetmask()); |
| response.setVpcId(result.getVpcId()); |
| response.setZoneId(result.getZoneId()); |
| DataCenter zone = ApiDBUtils.findZoneById(result.getZoneId()); |
| response.setZoneName(zone.getName()); |
| response.setAddress(result.getIp4Address()); |
| response.setPhysicalNetworkId(result.getPhysicalNetworkId()); |
| |
| populateAccount(response, result.getAccountId()); |
| populateDomain(response, result.getDomainId()); |
| response.setState(result.getState().toString()); |
| |
| response.setObjectName("privategateway"); |
| |
| |
| return response; |
| } |
| |
| @Override |
| public CounterResponse createCounterResponse(Counter counter) { |
| CounterResponse response = new CounterResponse(); |
| response.setId(counter.getId()); |
| response.setSource(counter.getSource().toString()); |
| response.setName(counter.getName()); |
| response.setValue(counter.getValue()); |
| response.setObjectName("counter"); |
| return response; |
| } |
| |
| @Override |
| public ConditionResponse createConditionResponse(Condition condition) { |
| ConditionResponse response = new ConditionResponse(); |
| response.setId(condition.getId()); |
| List<CounterResponse> counterResponseList = new ArrayList<CounterResponse>(); |
| counterResponseList.add(createCounterResponse(ApiDBUtils.getCounter(condition.getCounterid()))); |
| response.setCounterResponse(counterResponseList); |
| response.setRelationalOperator(condition.getRelationalOperator().toString()); |
| response.setThreshold(condition.getThreshold()); |
| response.setObjectName("condition"); |
| populateOwner(response, condition); |
| return response; |
| } |
| |
| @Override |
| public AutoScaleVmProfileResponse createAutoScaleVmProfileResponse(AutoScaleVmProfile profile) { |
| AutoScaleVmProfileResponse response = new AutoScaleVmProfileResponse(); |
| response.setId(profile.getId()); |
| response.setZoneId(profile.getZoneId()); |
| response.setServiceOfferingId(profile.getServiceOfferingId()); |
| response.setTemplateId(profile.getTemplateId()); |
| response.setOtherDeployParams(profile.getOtherDeployParams()); |
| response.setCounterParams(profile.getCounterParams()); |
| response.setDestroyVmGraceperiod(profile.getDestroyVmGraceperiod()); |
| response.setAutoscaleUserId(profile.getAutoScaleUserId()); |
| response.setObjectName("autoscalevmprofile"); |
| |
| // Populates the account information in the response |
| populateOwner(response, profile); |
| return response; |
| } |
| |
| @Override |
| public AutoScalePolicyResponse createAutoScalePolicyResponse(AutoScalePolicy policy) { |
| AutoScalePolicyResponse response = new AutoScalePolicyResponse(); |
| response.setId(policy.getId()); |
| response.setDuration(policy.getDuration()); |
| response.setQuietTime(policy.getQuietTime()); |
| response.setAction(policy.getAction()); |
| List<ConditionVO> vos = ApiDBUtils.getAutoScalePolicyConditions(policy.getId()); |
| ArrayList<ConditionResponse> conditions = new ArrayList<ConditionResponse>(vos.size()); |
| for (ConditionVO vo : vos) { |
| conditions.add(createConditionResponse(vo)); |
| } |
| response.setConditions(conditions); |
| response.setObjectName("autoscalepolicy"); |
| |
| // Populates the account information in the response |
| populateOwner(response, policy); |
| |
| return response; |
| } |
| |
| @Override |
| public AutoScaleVmGroupResponse createAutoScaleVmGroupResponse(AutoScaleVmGroup vmGroup) { |
| AutoScaleVmGroupResponse response = new AutoScaleVmGroupResponse(); |
| response.setId(vmGroup.getId()); |
| response.setMinMembers(vmGroup.getMinMembers()); |
| response.setMaxMembers(vmGroup.getMaxMembers()); |
| response.setState(vmGroup.getState()); |
| response.setInterval(vmGroup.getInterval()); |
| response.setProfileId(vmGroup.getProfileId()); |
| response.setLoadBalancerId(vmGroup.getProfileId()); |
| |
| List<AutoScalePolicyResponse> scaleUpPoliciesResponse = new ArrayList<AutoScalePolicyResponse>(); |
| List<AutoScalePolicyResponse> scaleDownPoliciesResponse = new ArrayList<AutoScalePolicyResponse>(); |
| response.setScaleUpPolicies(scaleUpPoliciesResponse); |
| response.setScaleDownPolicies(scaleDownPoliciesResponse); |
| response.setObjectName("autoscalevmgroup"); |
| |
| // Fetch policies for vmgroup |
| List<AutoScalePolicy> scaleUpPolicies = new ArrayList<AutoScalePolicy>(); |
| List<AutoScalePolicy> scaleDownPolicies = new ArrayList<AutoScalePolicy>(); |
| ApiDBUtils.getAutoScaleVmGroupPolicies(vmGroup.getId(), scaleUpPolicies, scaleDownPolicies); |
| // populate policies |
| for (AutoScalePolicy autoScalePolicy : scaleUpPolicies) { |
| scaleUpPoliciesResponse.add(createAutoScalePolicyResponse(autoScalePolicy)); |
| } |
| for (AutoScalePolicy autoScalePolicy : scaleDownPolicies) { |
| scaleDownPoliciesResponse.add(createAutoScalePolicyResponse(autoScalePolicy)); |
| } |
| |
| return response; |
| } |
| |
| @Override |
| public StaticRouteResponse createStaticRouteResponse(StaticRoute result) { |
| StaticRouteResponse response = new StaticRouteResponse(); |
| response.setId(result.getId()); |
| response.setVpcId(result.getVpcId()); |
| response.setCidr(result.getCidr()); |
| |
| StaticRoute.State state = result.getState(); |
| String stateToSet = state.toString(); |
| if (state.equals(FirewallRule.State.Revoke)) { |
| stateToSet = "Deleting"; |
| } |
| response.setState(stateToSet); |
| populateAccount(response, result.getAccountId()); |
| populateDomain(response, result.getDomainId()); |
| |
| //set tag information |
| List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(TaggedResourceType.StaticRoute, result.getId()); |
| List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>(); |
| for (ResourceTag tag : tags) { |
| ResourceTagResponse tagResponse = createResourceTagResponse(tag, true); |
| tagResponses.add(tagResponse); |
| } |
| response.setTags(tagResponses); |
| response.setObjectName("staticroute"); |
| |
| return response; |
| } |
| |
| @Override |
| public Site2SiteVpnGatewayResponse createSite2SiteVpnGatewayResponse(Site2SiteVpnGateway result) { |
| Site2SiteVpnGatewayResponse response = new Site2SiteVpnGatewayResponse(); |
| response.setId(result.getId()); |
| response.setIp(ApiDBUtils.findIpAddressById(result.getAddrId()).getAddress().toString()); |
| response.setVpcId(result.getVpcId()); |
| response.setRemoved(result.getRemoved()); |
| response.setObjectName("vpngateway"); |
| |
| populateAccount(response, result.getAccountId()); |
| populateDomain(response, result.getDomainId()); |
| return response; |
| } |
| |
| @Override |
| public Site2SiteCustomerGatewayResponse createSite2SiteCustomerGatewayResponse(Site2SiteCustomerGateway result) { |
| Site2SiteCustomerGatewayResponse response = new Site2SiteCustomerGatewayResponse(); |
| response.setId(result.getId()); |
| response.setName(result.getName()); |
| response.setGatewayIp(result.getGatewayIp()); |
| response.setGuestCidrList(result.getGuestCidrList()); |
| response.setIpsecPsk(result.getIpsecPsk()); |
| response.setIkePolicy(result.getIkePolicy()); |
| response.setEspPolicy(result.getEspPolicy()); |
| response.setIkeLifetime(result.getIkeLifetime()); |
| response.setEspLifetime(result.getEspLifetime()); |
| response.setDpd(result.getDpd()); |
| |
| response.setRemoved(result.getRemoved()); |
| response.setObjectName("vpncustomergateway"); |
| |
| populateAccount(response, result.getAccountId()); |
| populateDomain(response, result.getDomainId()); |
| |
| return response; |
| } |
| |
| @Override |
| public Site2SiteVpnConnectionResponse createSite2SiteVpnConnectionResponse(Site2SiteVpnConnection result) { |
| Site2SiteVpnConnectionResponse response = new Site2SiteVpnConnectionResponse(); |
| response.setId(result.getId()); |
| |
| response.setVpnGatewayId(result.getVpnGatewayId()); |
| Long vpnGatewayId = result.getVpnGatewayId(); |
| if(vpnGatewayId != null) { |
| Site2SiteVpnGatewayVO vpnGateway = ApiDBUtils.findVpnGatewayById(vpnGatewayId); |
| |
| long ipId = vpnGateway.getAddrId(); |
| IPAddressVO ipObj = ApiDBUtils.findIpAddressById(ipId); |
| response.setIp(ipObj.getAddress().addr()); |
| } |
| |
| response.setCustomerGatewayId(result.getCustomerGatewayId()); |
| Long customerGatewayId = result.getCustomerGatewayId(); |
| if(customerGatewayId != null) { |
| Site2SiteCustomerGatewayVO customerGateway = ApiDBUtils.findCustomerGatewayById(customerGatewayId); |
| response.setGatewayIp(customerGateway.getGatewayIp()); |
| response.setGuestCidrList(customerGateway.getGuestCidrList()); |
| response.setIpsecPsk(customerGateway.getIpsecPsk()); |
| response.setIkePolicy(customerGateway.getIkePolicy()); |
| response.setEspPolicy(customerGateway.getEspPolicy()); |
| response.setIkeLifetime(customerGateway.getIkeLifetime()); |
| response.setEspLifetime(customerGateway.getEspLifetime()); |
| response.setDpd(customerGateway.getDpd()); |
| } |
| |
| populateAccount(response, result.getAccountId()); |
| populateDomain(response, result.getDomainId()); |
| |
| response.setState(result.getState().toString()); |
| response.setCreated(result.getCreated()); |
| response.setRemoved(result.getRemoved()); |
| response.setObjectName("vpnconnection"); |
| return response; |
| } |
| } |
