mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
7efdaa65f7
* [CLOUDSTACK-10314] Add Text-Field to each ACL Rule It is interesting to have a text field (e.g. CHAR-256) added to each ACL rule, which allows to enter a "reason" for each FW Rule created. This is valuable for customer documentation, as well as best practice for an evidence towards auditing the system * Formatting to make check style happy and code clean ups
3967 lines
180 KiB
Java
3967 lines
180 KiB
Java
// 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 com.cloud.utils.crypt.DBEncryptionUtil;
|
|
import com.cloud.tags.dao.ResourceTagDao;
|
|
import com.cloud.agent.api.VgpuTypesInfo;
|
|
import com.cloud.api.query.ViewResponseHelper;
|
|
import com.cloud.api.query.vo.AccountJoinVO;
|
|
import com.cloud.api.query.vo.AsyncJobJoinVO;
|
|
import com.cloud.api.query.vo.ControlledViewEntity;
|
|
import com.cloud.api.query.vo.DataCenterJoinVO;
|
|
import com.cloud.api.query.vo.DiskOfferingJoinVO;
|
|
import com.cloud.api.query.vo.DomainRouterJoinVO;
|
|
import com.cloud.api.query.vo.EventJoinVO;
|
|
import com.cloud.api.query.vo.HostJoinVO;
|
|
import com.cloud.api.query.vo.ImageStoreJoinVO;
|
|
import com.cloud.api.query.vo.InstanceGroupJoinVO;
|
|
import com.cloud.api.query.vo.ProjectAccountJoinVO;
|
|
import com.cloud.api.query.vo.ProjectInvitationJoinVO;
|
|
import com.cloud.api.query.vo.ProjectJoinVO;
|
|
import com.cloud.api.query.vo.ResourceTagJoinVO;
|
|
import com.cloud.api.query.vo.SecurityGroupJoinVO;
|
|
import com.cloud.api.query.vo.ServiceOfferingJoinVO;
|
|
import com.cloud.api.query.vo.StoragePoolJoinVO;
|
|
import com.cloud.api.query.vo.TemplateJoinVO;
|
|
import com.cloud.api.query.vo.UserAccountJoinVO;
|
|
import com.cloud.api.query.vo.UserVmJoinVO;
|
|
import com.cloud.api.query.vo.VolumeJoinVO;
|
|
import com.cloud.api.response.ApiResponseSerializer;
|
|
import com.cloud.capacity.Capacity;
|
|
import com.cloud.capacity.CapacityVO;
|
|
import com.cloud.capacity.dao.CapacityDaoImpl.SummedCapacity;
|
|
import com.cloud.configuration.ConfigurationManager;
|
|
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.ClusterDetailsDao;
|
|
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.domain.DomainVO;
|
|
import com.cloud.event.Event;
|
|
import com.cloud.exception.InvalidParameterValueException;
|
|
import com.cloud.exception.PermissionDeniedException;
|
|
import com.cloud.gpu.GPU;
|
|
import com.cloud.host.Host;
|
|
import com.cloud.host.HostVO;
|
|
import com.cloud.hypervisor.HypervisorCapabilities;
|
|
import com.cloud.network.GuestVlan;
|
|
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.NetworkModel;
|
|
import com.cloud.network.NetworkProfile;
|
|
import com.cloud.network.Networks.BroadcastDomainType;
|
|
import com.cloud.network.Networks.IsolationType;
|
|
import com.cloud.network.Networks.TrafficType;
|
|
import com.cloud.network.OvsProvider;
|
|
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.Site2SiteVpnConnection;
|
|
import com.cloud.network.Site2SiteVpnGateway;
|
|
import com.cloud.network.VirtualRouterProvider;
|
|
import com.cloud.network.VpnUser;
|
|
import com.cloud.network.VpnUserVO;
|
|
import com.cloud.network.as.AutoScalePolicy;
|
|
import com.cloud.network.as.AutoScaleVmGroup;
|
|
import com.cloud.network.as.AutoScaleVmProfile;
|
|
import com.cloud.network.as.AutoScaleVmProfileVO;
|
|
import com.cloud.network.as.Condition;
|
|
import com.cloud.network.as.ConditionVO;
|
|
import com.cloud.network.as.Counter;
|
|
import com.cloud.network.dao.IPAddressDao;
|
|
import com.cloud.network.dao.IPAddressVO;
|
|
import com.cloud.network.dao.LoadBalancerVO;
|
|
import com.cloud.network.dao.NetworkVO;
|
|
import com.cloud.network.dao.PhysicalNetworkVO;
|
|
import com.cloud.network.router.VirtualRouter;
|
|
import com.cloud.network.rules.FirewallRule;
|
|
import com.cloud.network.rules.FirewallRuleVO;
|
|
import com.cloud.network.rules.HealthCheckPolicy;
|
|
import com.cloud.network.rules.LoadBalancer;
|
|
import com.cloud.network.rules.LoadBalancerContainer.Scheme;
|
|
import com.cloud.network.rules.PortForwardingRule;
|
|
import com.cloud.network.rules.PortForwardingRuleVO;
|
|
import com.cloud.network.rules.StaticNatRule;
|
|
import com.cloud.network.rules.StickinessPolicy;
|
|
import com.cloud.network.security.SecurityGroup;
|
|
import com.cloud.network.security.SecurityGroupVO;
|
|
import com.cloud.network.security.SecurityRule;
|
|
import com.cloud.network.security.SecurityRule.SecurityRuleType;
|
|
import com.cloud.network.vpc.NetworkACL;
|
|
import com.cloud.network.vpc.NetworkACLItem;
|
|
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.NetworkOffering.Detail;
|
|
import com.cloud.offering.ServiceOffering;
|
|
import com.cloud.offerings.NetworkOfferingVO;
|
|
import com.cloud.org.Cluster;
|
|
import com.cloud.projects.Project;
|
|
import com.cloud.projects.ProjectAccount;
|
|
import com.cloud.projects.ProjectInvitation;
|
|
import com.cloud.region.ha.GlobalLoadBalancerRule;
|
|
import com.cloud.server.ResourceTag;
|
|
import com.cloud.server.ResourceTag.ResourceObjectType;
|
|
import com.cloud.service.ServiceOfferingVO;
|
|
import com.cloud.storage.DataStoreRole;
|
|
import com.cloud.storage.DiskOfferingVO;
|
|
import com.cloud.storage.GuestOS;
|
|
import com.cloud.storage.GuestOSCategoryVO;
|
|
import com.cloud.storage.GuestOSHypervisor;
|
|
import com.cloud.storage.ImageStore;
|
|
import com.cloud.storage.Snapshot;
|
|
import com.cloud.storage.SnapshotVO;
|
|
import com.cloud.storage.StoragePool;
|
|
import com.cloud.storage.Upload;
|
|
import com.cloud.storage.UploadVO;
|
|
import com.cloud.storage.VMTemplateVO;
|
|
import com.cloud.storage.Volume;
|
|
import com.cloud.storage.VolumeVO;
|
|
import com.cloud.storage.dao.VolumeDao;
|
|
import com.cloud.storage.snapshot.SnapshotPolicy;
|
|
import com.cloud.storage.snapshot.SnapshotSchedule;
|
|
import com.cloud.template.VirtualMachineTemplate;
|
|
import com.cloud.user.Account;
|
|
import com.cloud.user.AccountManager;
|
|
import com.cloud.user.SSHKeyPair;
|
|
import com.cloud.user.User;
|
|
import com.cloud.user.UserAccount;
|
|
import com.cloud.uservm.UserVm;
|
|
import com.cloud.utils.Pair;
|
|
import com.cloud.utils.StringUtils;
|
|
import com.cloud.utils.db.EntityManager;
|
|
import com.cloud.utils.net.Dhcp;
|
|
import com.cloud.utils.db.SearchBuilder;
|
|
import com.cloud.utils.db.SearchCriteria;
|
|
import com.cloud.utils.exception.CloudRuntimeException;
|
|
import com.cloud.utils.net.Ip;
|
|
import com.cloud.utils.net.NetUtils;
|
|
import com.cloud.vm.ConsoleProxyVO;
|
|
import com.cloud.vm.InstanceGroup;
|
|
import com.cloud.vm.Nic;
|
|
import com.cloud.vm.NicExtraDhcpOptionVO;
|
|
import com.cloud.vm.NicProfile;
|
|
import com.cloud.vm.NicSecondaryIp;
|
|
import com.cloud.vm.NicVO;
|
|
import com.cloud.vm.VMInstanceVO;
|
|
import com.cloud.vm.VirtualMachine;
|
|
import com.cloud.vm.VirtualMachine.Type;
|
|
import com.cloud.vm.dao.NicExtraDhcpOptionDao;
|
|
import com.cloud.vm.dao.NicSecondaryIpVO;
|
|
import com.cloud.vm.snapshot.VMSnapshot;
|
|
import org.apache.cloudstack.acl.ControlledEntity;
|
|
import org.apache.cloudstack.acl.ControlledEntity.ACLType;
|
|
import org.apache.cloudstack.affinity.AffinityGroup;
|
|
import org.apache.cloudstack.affinity.AffinityGroupResponse;
|
|
import org.apache.cloudstack.api.ApiConstants.HostDetails;
|
|
import org.apache.cloudstack.api.ApiConstants.VMDetails;
|
|
import org.apache.cloudstack.api.ResponseGenerator;
|
|
import org.apache.cloudstack.api.ResponseObject.ResponseView;
|
|
import org.apache.cloudstack.api.command.user.job.QueryAsyncJobResultCmd;
|
|
import org.apache.cloudstack.api.response.AccountResponse;
|
|
import org.apache.cloudstack.api.response.ApplicationLoadBalancerInstanceResponse;
|
|
import org.apache.cloudstack.api.response.ApplicationLoadBalancerResponse;
|
|
import org.apache.cloudstack.api.response.ApplicationLoadBalancerRuleResponse;
|
|
import org.apache.cloudstack.api.response.AsyncJobResponse;
|
|
import org.apache.cloudstack.api.response.AutoScalePolicyResponse;
|
|
import org.apache.cloudstack.api.response.AutoScaleVmGroupResponse;
|
|
import org.apache.cloudstack.api.response.AutoScaleVmProfileResponse;
|
|
import org.apache.cloudstack.api.response.CapabilityResponse;
|
|
import org.apache.cloudstack.api.response.CapacityResponse;
|
|
import org.apache.cloudstack.api.response.ClusterResponse;
|
|
import org.apache.cloudstack.api.response.ConditionResponse;
|
|
import org.apache.cloudstack.api.response.ConfigurationResponse;
|
|
import org.apache.cloudstack.api.response.ControlledEntityResponse;
|
|
import org.apache.cloudstack.api.response.ControlledViewEntityResponse;
|
|
import org.apache.cloudstack.api.response.CounterResponse;
|
|
import org.apache.cloudstack.api.response.CreateCmdResponse;
|
|
import org.apache.cloudstack.api.response.CreateSSHKeyPairResponse;
|
|
import org.apache.cloudstack.api.response.DiskOfferingResponse;
|
|
import org.apache.cloudstack.api.response.DomainResponse;
|
|
import org.apache.cloudstack.api.response.DomainRouterResponse;
|
|
import org.apache.cloudstack.api.response.EventResponse;
|
|
import org.apache.cloudstack.api.response.ExtractResponse;
|
|
import org.apache.cloudstack.api.response.FirewallResponse;
|
|
import org.apache.cloudstack.api.response.FirewallRuleResponse;
|
|
import org.apache.cloudstack.api.response.GlobalLoadBalancerResponse;
|
|
import org.apache.cloudstack.api.response.GuestOSResponse;
|
|
import org.apache.cloudstack.api.response.GuestOsMappingResponse;
|
|
import org.apache.cloudstack.api.response.GuestVlanRangeResponse;
|
|
import org.apache.cloudstack.api.response.HostForMigrationResponse;
|
|
import org.apache.cloudstack.api.response.HostResponse;
|
|
import org.apache.cloudstack.api.response.HypervisorCapabilitiesResponse;
|
|
import org.apache.cloudstack.api.response.IPAddressResponse;
|
|
import org.apache.cloudstack.api.response.ImageStoreResponse;
|
|
import org.apache.cloudstack.api.response.InstanceGroupResponse;
|
|
import org.apache.cloudstack.api.response.InternalLoadBalancerElementResponse;
|
|
import org.apache.cloudstack.api.response.IpForwardingRuleResponse;
|
|
import org.apache.cloudstack.api.response.IsolationMethodResponse;
|
|
import org.apache.cloudstack.api.response.LBHealthCheckPolicyResponse;
|
|
import org.apache.cloudstack.api.response.LBHealthCheckResponse;
|
|
import org.apache.cloudstack.api.response.LBStickinessPolicyResponse;
|
|
import org.apache.cloudstack.api.response.LBStickinessResponse;
|
|
import org.apache.cloudstack.api.response.ListResponse;
|
|
import org.apache.cloudstack.api.response.LoadBalancerResponse;
|
|
import org.apache.cloudstack.api.response.NetworkACLItemResponse;
|
|
import org.apache.cloudstack.api.response.NetworkACLResponse;
|
|
import org.apache.cloudstack.api.response.NetworkOfferingResponse;
|
|
import org.apache.cloudstack.api.response.NetworkResponse;
|
|
import org.apache.cloudstack.api.response.NicExtraDhcpOptionResponse;
|
|
import org.apache.cloudstack.api.response.NicResponse;
|
|
import org.apache.cloudstack.api.response.NicSecondaryIpResponse;
|
|
import org.apache.cloudstack.api.response.OvsProviderResponse;
|
|
import org.apache.cloudstack.api.response.PhysicalNetworkResponse;
|
|
import org.apache.cloudstack.api.response.PodResponse;
|
|
import org.apache.cloudstack.api.response.PortableIpRangeResponse;
|
|
import org.apache.cloudstack.api.response.PortableIpResponse;
|
|
import org.apache.cloudstack.api.response.PrivateGatewayResponse;
|
|
import org.apache.cloudstack.api.response.ProjectAccountResponse;
|
|
import org.apache.cloudstack.api.response.ProjectInvitationResponse;
|
|
import org.apache.cloudstack.api.response.ProjectResponse;
|
|
import org.apache.cloudstack.api.response.ProviderResponse;
|
|
import org.apache.cloudstack.api.response.RegionResponse;
|
|
import org.apache.cloudstack.api.response.RemoteAccessVpnResponse;
|
|
import org.apache.cloudstack.api.response.ResourceCountResponse;
|
|
import org.apache.cloudstack.api.response.ResourceLimitResponse;
|
|
import org.apache.cloudstack.api.response.ResourceTagResponse;
|
|
import org.apache.cloudstack.api.response.SSHKeyPairResponse;
|
|
import org.apache.cloudstack.api.response.SecurityGroupResponse;
|
|
import org.apache.cloudstack.api.response.SecurityGroupRuleResponse;
|
|
import org.apache.cloudstack.api.response.ServiceOfferingResponse;
|
|
import org.apache.cloudstack.api.response.ServiceResponse;
|
|
import org.apache.cloudstack.api.response.Site2SiteCustomerGatewayResponse;
|
|
import org.apache.cloudstack.api.response.Site2SiteVpnConnectionResponse;
|
|
import org.apache.cloudstack.api.response.Site2SiteVpnGatewayResponse;
|
|
import org.apache.cloudstack.api.response.SnapshotPolicyResponse;
|
|
import org.apache.cloudstack.api.response.SnapshotResponse;
|
|
import org.apache.cloudstack.api.response.SnapshotScheduleResponse;
|
|
import org.apache.cloudstack.api.response.StaticRouteResponse;
|
|
import org.apache.cloudstack.api.response.StorageNetworkIpRangeResponse;
|
|
import org.apache.cloudstack.api.response.StoragePoolResponse;
|
|
import org.apache.cloudstack.api.response.SystemVmInstanceResponse;
|
|
import org.apache.cloudstack.api.response.SystemVmResponse;
|
|
import org.apache.cloudstack.api.response.TemplatePermissionsResponse;
|
|
import org.apache.cloudstack.api.response.TemplateResponse;
|
|
import org.apache.cloudstack.api.response.TrafficMonitorResponse;
|
|
import org.apache.cloudstack.api.response.TrafficTypeResponse;
|
|
import org.apache.cloudstack.api.response.UpgradeRouterTemplateResponse;
|
|
import org.apache.cloudstack.api.response.UsageRecordResponse;
|
|
import org.apache.cloudstack.api.response.UserResponse;
|
|
import org.apache.cloudstack.api.response.UserVmResponse;
|
|
import org.apache.cloudstack.api.response.VMSnapshotResponse;
|
|
import org.apache.cloudstack.api.response.VirtualRouterProviderResponse;
|
|
import org.apache.cloudstack.api.response.VlanIpRangeResponse;
|
|
import org.apache.cloudstack.api.response.VolumeResponse;
|
|
import org.apache.cloudstack.api.response.VpcOfferingResponse;
|
|
import org.apache.cloudstack.api.response.VpcResponse;
|
|
import org.apache.cloudstack.api.response.VpnUsersResponse;
|
|
import org.apache.cloudstack.api.response.ZoneResponse;
|
|
import org.apache.cloudstack.config.Configuration;
|
|
import org.apache.cloudstack.context.CallContext;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.DataStore;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreCapabilities;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotDataFactory;
|
|
import org.apache.cloudstack.engine.subsystem.api.storage.SnapshotInfo;
|
|
import org.apache.cloudstack.framework.jobs.AsyncJob;
|
|
import org.apache.cloudstack.framework.jobs.AsyncJobManager;
|
|
import org.apache.cloudstack.network.lb.ApplicationLoadBalancerRule;
|
|
import org.apache.cloudstack.region.PortableIp;
|
|
import org.apache.cloudstack.region.PortableIpRange;
|
|
import org.apache.cloudstack.region.Region;
|
|
import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
|
|
import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreDao;
|
|
import org.apache.cloudstack.storage.datastore.db.SnapshotDataStoreVO;
|
|
import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
|
|
import org.apache.cloudstack.usage.Usage;
|
|
import org.apache.cloudstack.usage.UsageService;
|
|
import org.apache.cloudstack.usage.UsageTypes;
|
|
import org.apache.commons.collections.CollectionUtils;
|
|
import org.apache.log4j.Logger;
|
|
|
|
import javax.inject.Inject;
|
|
import java.text.DecimalFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Calendar;
|
|
import java.util.Date;
|
|
import java.util.EnumSet;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.TimeZone;
|
|
import java.util.stream.Collectors;
|
|
|
|
public class ApiResponseHelper implements ResponseGenerator {
|
|
|
|
private static final Logger s_logger = Logger.getLogger(ApiResponseHelper.class);
|
|
private static final DecimalFormat s_percentFormat = new DecimalFormat("##.##");
|
|
|
|
@Inject
|
|
private EntityManager _entityMgr;
|
|
@Inject
|
|
private UsageService _usageSvc;
|
|
@Inject
|
|
NetworkModel _ntwkModel;
|
|
@Inject
|
|
protected AccountManager _accountMgr;
|
|
@Inject
|
|
protected AsyncJobManager _jobMgr;
|
|
@Inject
|
|
ConfigurationManager _configMgr;
|
|
@Inject
|
|
SnapshotDataFactory snapshotfactory;
|
|
@Inject
|
|
private VolumeDao _volumeDao;
|
|
@Inject
|
|
private DataStoreManager _dataStoreMgr;
|
|
@Inject
|
|
private SnapshotDataStoreDao _snapshotStoreDao;
|
|
@Inject
|
|
private PrimaryDataStoreDao _storagePoolDao;
|
|
@Inject
|
|
private ClusterDetailsDao _clusterDetailsDao;
|
|
@Inject
|
|
private ResourceTagDao _resourceTagDao;
|
|
@Inject
|
|
private NicExtraDhcpOptionDao _nicExtraDhcpOptionDao;
|
|
@Inject
|
|
private IPAddressDao userIpAddressDao;
|
|
|
|
@Override
|
|
public UserResponse createUserResponse(User user) {
|
|
UserAccountJoinVO vUser = ApiDBUtils.newUserView(user);
|
|
return ApiDBUtils.newUserResponse(vUser);
|
|
}
|
|
|
|
// this method is used for response generation via createAccount (which
|
|
// creates an account + user)
|
|
@Override
|
|
public AccountResponse createUserAccountResponse(ResponseView view, UserAccount user) {
|
|
return ApiDBUtils.newAccountResponse(view, ApiDBUtils.findAccountViewById(user.getAccountId()));
|
|
}
|
|
|
|
@Override
|
|
public AccountResponse createAccountResponse(ResponseView view, Account account) {
|
|
AccountJoinVO vUser = ApiDBUtils.newAccountView(account);
|
|
return ApiDBUtils.newAccountResponse(view, vUser);
|
|
}
|
|
|
|
@Override
|
|
public UserResponse createUserResponse(UserAccount user) {
|
|
UserAccountJoinVO vUser = ApiDBUtils.newUserView(user);
|
|
return ApiDBUtils.newUserResponse(vUser);
|
|
}
|
|
|
|
@Override
|
|
public DomainResponse createDomainResponse(Domain domain) {
|
|
DomainResponse domainResponse = new DomainResponse();
|
|
domainResponse.setDomainName(domain.getName());
|
|
domainResponse.setId(domain.getUuid());
|
|
domainResponse.setLevel(domain.getLevel());
|
|
domainResponse.setNetworkDomain(domain.getNetworkDomain());
|
|
Domain parentDomain = ApiDBUtils.findDomainById(domain.getParent());
|
|
if (parentDomain != null) {
|
|
domainResponse.setParentDomainId(parentDomain.getUuid());
|
|
}
|
|
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) {
|
|
DiskOfferingJoinVO vOffering = ApiDBUtils.newDiskOfferingView(offering);
|
|
return ApiDBUtils.newDiskOfferingResponse(vOffering);
|
|
}
|
|
|
|
@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(limit.getType());
|
|
|
|
if ((limit.getType() == ResourceType.primary_storage || limit.getType() == ResourceType.secondary_storage) && limit.getMax() >= 0) {
|
|
resourceLimitResponse.setMax((long)Math.ceil((double)limit.getMax() / ResourceType.bytesToGiB));
|
|
} else {
|
|
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(resourceCount.getType());
|
|
resourceCountResponse.setResourceCount(resourceCount.getCount());
|
|
resourceCountResponse.setObjectName("resourcecount");
|
|
return resourceCountResponse;
|
|
}
|
|
|
|
@Override
|
|
public ServiceOfferingResponse createServiceOfferingResponse(ServiceOffering offering) {
|
|
ServiceOfferingJoinVO vOffering = ApiDBUtils.newServiceOfferingView(offering);
|
|
return ApiDBUtils.newServiceOfferingResponse(vOffering);
|
|
}
|
|
|
|
@Override
|
|
public ConfigurationResponse createConfigurationResponse(Configuration cfg) {
|
|
ConfigurationResponse cfgResponse = new ConfigurationResponse();
|
|
cfgResponse.setCategory(cfg.getCategory());
|
|
cfgResponse.setDescription(cfg.getDescription());
|
|
cfgResponse.setName(cfg.getName());
|
|
if(cfg.isEncrypted()) {
|
|
cfgResponse.setValue(DBEncryptionUtil.encrypt(cfg.getValue()));
|
|
} else {
|
|
cfgResponse.setValue(cfg.getValue());
|
|
}
|
|
cfgResponse.setObjectName("configuration");
|
|
|
|
return cfgResponse;
|
|
}
|
|
|
|
@Override
|
|
public SnapshotResponse createSnapshotResponse(Snapshot snapshot) {
|
|
SnapshotResponse snapshotResponse = new SnapshotResponse();
|
|
snapshotResponse.setId(snapshot.getUuid());
|
|
|
|
populateOwner(snapshotResponse, snapshot);
|
|
|
|
VolumeVO volume = findVolumeById(snapshot.getVolumeId());
|
|
String snapshotTypeStr = snapshot.getRecurringType().name();
|
|
snapshotResponse.setSnapshotType(snapshotTypeStr);
|
|
if (volume != null) {
|
|
snapshotResponse.setVolumeId(volume.getUuid());
|
|
snapshotResponse.setVolumeName(volume.getName());
|
|
snapshotResponse.setVolumeType(volume.getVolumeType().name());
|
|
snapshotResponse.setVirtualSize(volume.getSize());
|
|
DataCenter zone = ApiDBUtils.findZoneById(volume.getDataCenterId());
|
|
if (zone != null) {
|
|
snapshotResponse.setZoneId(zone.getUuid());
|
|
}
|
|
|
|
if (volume.getVolumeType() == Volume.Type.ROOT) {
|
|
//TODO combine lines and 489 into a join in the volume dao
|
|
VMInstanceVO instance = ApiDBUtils.findVMInstanceById(volume.getInstanceId());
|
|
if (instance != null) {
|
|
GuestOS guestOs = ApiDBUtils.findGuestOSById(instance.getGuestOSId());
|
|
if (guestOs != null) {
|
|
snapshotResponse.setOsTypeId(guestOs.getUuid());
|
|
snapshotResponse.setOsDisplayName(guestOs.getDisplayName());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
snapshotResponse.setCreated(snapshot.getCreated());
|
|
snapshotResponse.setName(snapshot.getName());
|
|
snapshotResponse.setIntervalType(ApiDBUtils.getSnapshotIntervalTypes(snapshot.getId()));
|
|
snapshotResponse.setState(snapshot.getState());
|
|
snapshotResponse.setLocationType(ApiDBUtils.getSnapshotLocationType(snapshot.getId()));
|
|
|
|
SnapshotInfo snapshotInfo = null;
|
|
|
|
if (snapshot instanceof SnapshotInfo) {
|
|
snapshotInfo = (SnapshotInfo)snapshot;
|
|
} else {
|
|
DataStoreRole dataStoreRole = getDataStoreRole(snapshot, _snapshotStoreDao, _dataStoreMgr);
|
|
|
|
snapshotInfo = snapshotfactory.getSnapshot(snapshot.getId(), dataStoreRole);
|
|
}
|
|
|
|
if (snapshotInfo == null) {
|
|
s_logger.debug("Unable to find info for image store snapshot with uuid " + snapshot.getUuid());
|
|
snapshotResponse.setRevertable(false);
|
|
} else {
|
|
snapshotResponse.setRevertable(snapshotInfo.isRevertable());
|
|
snapshotResponse.setPhysicaSize(snapshotInfo.getPhysicalSize());
|
|
}
|
|
|
|
// set tag information
|
|
List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(ResourceObjectType.Snapshot, snapshot.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses, tagResponse);
|
|
}
|
|
snapshotResponse.setTags(tagResponses);
|
|
|
|
snapshotResponse.setObjectName("snapshot");
|
|
return snapshotResponse;
|
|
}
|
|
|
|
public static DataStoreRole getDataStoreRole(Snapshot snapshot, SnapshotDataStoreDao snapshotStoreDao, DataStoreManager dataStoreMgr) {
|
|
SnapshotDataStoreVO snapshotStore = snapshotStoreDao.findBySnapshot(snapshot.getId(), DataStoreRole.Primary);
|
|
|
|
if (snapshotStore == null) {
|
|
return DataStoreRole.Image;
|
|
}
|
|
|
|
long storagePoolId = snapshotStore.getDataStoreId();
|
|
DataStore dataStore = dataStoreMgr.getDataStore(storagePoolId, DataStoreRole.Primary);
|
|
if (dataStore == null) {
|
|
return DataStoreRole.Image;
|
|
}
|
|
|
|
Map<String, String> mapCapabilities = dataStore.getDriver().getCapabilities();
|
|
|
|
if (mapCapabilities != null) {
|
|
String value = mapCapabilities.get(DataStoreCapabilities.STORAGE_SYSTEM_SNAPSHOT.toString());
|
|
Boolean supportsStorageSystemSnapshots = new Boolean(value);
|
|
|
|
if (supportsStorageSystemSnapshots) {
|
|
return DataStoreRole.Primary;
|
|
}
|
|
}
|
|
|
|
return DataStoreRole.Image;
|
|
}
|
|
|
|
@Override
|
|
public VMSnapshotResponse createVMSnapshotResponse(VMSnapshot vmSnapshot) {
|
|
VMSnapshotResponse vmSnapshotResponse = new VMSnapshotResponse();
|
|
vmSnapshotResponse.setId(vmSnapshot.getUuid());
|
|
vmSnapshotResponse.setName(vmSnapshot.getName());
|
|
vmSnapshotResponse.setState(vmSnapshot.getState());
|
|
vmSnapshotResponse.setCreated(vmSnapshot.getCreated());
|
|
vmSnapshotResponse.setDescription(vmSnapshot.getDescription());
|
|
vmSnapshotResponse.setDisplayName(vmSnapshot.getDisplayName());
|
|
UserVm vm = ApiDBUtils.findUserVmById(vmSnapshot.getVmId());
|
|
if (vm != null) {
|
|
vmSnapshotResponse.setVirtualMachineid(vm.getUuid());
|
|
DataCenterVO datacenter = ApiDBUtils.findZoneById(vm.getDataCenterId());
|
|
if (datacenter != null) {
|
|
vmSnapshotResponse.setZoneId(datacenter.getUuid());
|
|
}
|
|
}
|
|
if (vmSnapshot.getParent() != null) {
|
|
VMSnapshot vmSnapshotParent = ApiDBUtils.getVMSnapshotById(vmSnapshot.getParent());
|
|
if (vmSnapshotParent != null) {
|
|
vmSnapshotResponse.setParent(vmSnapshotParent.getUuid());
|
|
vmSnapshotResponse.setParentName(vmSnapshotParent.getDisplayName());
|
|
}
|
|
}
|
|
populateOwner(vmSnapshotResponse, vmSnapshot);
|
|
Project project = ApiDBUtils.findProjectByProjectAccountId(vmSnapshot.getAccountId());
|
|
if (project != null) {
|
|
vmSnapshotResponse.setProjectId(project.getUuid());
|
|
vmSnapshotResponse.setProjectName(project.getName());
|
|
}
|
|
Account account = ApiDBUtils.findAccountById(vmSnapshot.getAccountId());
|
|
if (account != null) {
|
|
vmSnapshotResponse.setAccountName(account.getAccountName());
|
|
}
|
|
DomainVO domain = ApiDBUtils.findDomainById(vmSnapshot.getDomainId());
|
|
if (domain != null) {
|
|
vmSnapshotResponse.setDomainId(domain.getUuid());
|
|
vmSnapshotResponse.setDomainName(domain.getName());
|
|
}
|
|
|
|
vmSnapshotResponse.setCurrent(vmSnapshot.getCurrent());
|
|
vmSnapshotResponse.setType(vmSnapshot.getType().toString());
|
|
vmSnapshotResponse.setObjectName("vmsnapshot");
|
|
return vmSnapshotResponse;
|
|
}
|
|
|
|
@Override
|
|
public SnapshotPolicyResponse createSnapshotPolicyResponse(SnapshotPolicy policy) {
|
|
SnapshotPolicyResponse policyResponse = new SnapshotPolicyResponse();
|
|
policyResponse.setId(policy.getUuid());
|
|
Volume vol = ApiDBUtils.findVolumeById(policy.getVolumeId());
|
|
if (vol != null) {
|
|
policyResponse.setVolumeId(vol.getUuid());
|
|
}
|
|
policyResponse.setSchedule(policy.getSchedule());
|
|
policyResponse.setIntervalType(policy.getInterval());
|
|
policyResponse.setMaxSnaps(policy.getMaxSnaps());
|
|
policyResponse.setTimezone(policy.getTimezone());
|
|
policyResponse.setForDisplay(policy.isDisplay());
|
|
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) {
|
|
List<HostJoinVO> viewHosts = ApiDBUtils.newHostView(host);
|
|
List<HostResponse> listHosts = ViewResponseHelper.createHostResponse(details, viewHosts.toArray(new HostJoinVO[viewHosts.size()]));
|
|
assert listHosts != null && listHosts.size() == 1 : "There should be one host returned";
|
|
return listHosts.get(0);
|
|
}
|
|
|
|
@Override
|
|
public HostForMigrationResponse createHostForMigrationResponse(Host host) {
|
|
return createHostForMigrationResponse(host, EnumSet.of(HostDetails.all));
|
|
}
|
|
|
|
@Override
|
|
public HostForMigrationResponse createHostForMigrationResponse(Host host, EnumSet<HostDetails> details) {
|
|
List<HostJoinVO> viewHosts = ApiDBUtils.newHostView(host);
|
|
List<HostForMigrationResponse> listHosts = ViewResponseHelper.createHostForMigrationResponse(details, viewHosts.toArray(new HostJoinVO[viewHosts.size()]));
|
|
assert listHosts != null && listHosts.size() == 1 : "There should be one host returned";
|
|
return listHosts.get(0);
|
|
}
|
|
|
|
@Override
|
|
public VlanIpRangeResponse createVlanIpRangeResponse(Vlan vlan) {
|
|
return createVlanIpRangeResponse(VlanIpRangeResponse.class, vlan);
|
|
}
|
|
|
|
@Override
|
|
public VlanIpRangeResponse createVlanIpRangeResponse(Class<? extends VlanIpRangeResponse> subClass, Vlan vlan) {
|
|
try {
|
|
Long podId = ApiDBUtils.getPodIdForVlan(vlan.getId());
|
|
|
|
VlanIpRangeResponse vlanResponse = subClass.newInstance();
|
|
vlanResponse.setId(vlan.getUuid());
|
|
if (vlan.getVlanType() != null) {
|
|
vlanResponse.setForVirtualNetwork(vlan.getVlanType().equals(VlanType.VirtualNetwork));
|
|
}
|
|
vlanResponse.setVlan(vlan.getVlanTag());
|
|
DataCenter zone = ApiDBUtils.findZoneById(vlan.getDataCenterId());
|
|
if (zone != null) {
|
|
vlanResponse.setZoneId(zone.getUuid());
|
|
}
|
|
|
|
if (podId != null) {
|
|
HostPodVO pod = ApiDBUtils.findPodById(podId);
|
|
if (pod != null) {
|
|
vlanResponse.setPodId(pod.getUuid());
|
|
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]);
|
|
}
|
|
|
|
if (vlan.getNetworkId() != null) {
|
|
Network nw = ApiDBUtils.findNetworkById(vlan.getNetworkId());
|
|
if (nw != null) {
|
|
vlanResponse.setNetworkId(nw.getUuid());
|
|
}
|
|
}
|
|
Account owner = ApiDBUtils.getVlanAccount(vlan.getId());
|
|
if (owner != null) {
|
|
populateAccount(vlanResponse, owner.getId());
|
|
populateDomain(vlanResponse, owner.getDomainId());
|
|
} else {
|
|
Domain domain = ApiDBUtils.getVlanDomain(vlan.getId());
|
|
if (domain != null) {
|
|
populateDomain(vlanResponse, domain.getId());
|
|
} else {
|
|
Long networkId = vlan.getNetworkId();
|
|
if (networkId != null) {
|
|
Network network = _ntwkModel.getNetwork(networkId);
|
|
if (network != null) {
|
|
Long accountId = network.getAccountId();
|
|
populateAccount(vlanResponse, accountId);
|
|
populateDomain(vlanResponse, ApiDBUtils.findAccountById(accountId).getDomainId());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (vlan.getPhysicalNetworkId() != null) {
|
|
PhysicalNetwork pnw = ApiDBUtils.findPhysicalNetworkById(vlan.getPhysicalNetworkId());
|
|
if (pnw != null) {
|
|
vlanResponse.setPhysicalNetworkId(pnw.getUuid());
|
|
}
|
|
}
|
|
vlanResponse.setForSystemVms(isForSystemVms(vlan.getId()));
|
|
vlanResponse.setObjectName("vlan");
|
|
return vlanResponse;
|
|
} catch (InstantiationException | IllegalAccessException e) {
|
|
throw new CloudRuntimeException("Failed to create Vlan IP Range response", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if vlan IP range is dedicated for system vms (SSVM and CPVM), false if not
|
|
* @param vlanId vlan id
|
|
* @return true if VLAN IP range is dedicated to system vms
|
|
*/
|
|
private boolean isForSystemVms(long vlanId){
|
|
SearchBuilder<IPAddressVO> sb = userIpAddressDao.createSearchBuilder();
|
|
sb.and("vlanId", sb.entity().getVlanId(), SearchCriteria.Op.EQ);
|
|
SearchCriteria<IPAddressVO> sc = sb.create();
|
|
sc.setParameters("vlanId", vlanId);
|
|
IPAddressVO userIpAddresVO = userIpAddressDao.findOneBy(sc);
|
|
return userIpAddresVO.isForSystemVms();
|
|
}
|
|
|
|
@Override
|
|
public IPAddressResponse createIPAddressResponse(ResponseView view, 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.getUuid());
|
|
ipResponse.setIpAddress(ipAddr.getAddress().toString());
|
|
if (ipAddr.getAllocatedTime() != null) {
|
|
ipResponse.setAllocated(ipAddr.getAllocatedTime());
|
|
}
|
|
DataCenter zone = ApiDBUtils.findZoneById(ipAddr.getDataCenterId());
|
|
if (zone != null) {
|
|
ipResponse.setZoneId(zone.getUuid());
|
|
ipResponse.setZoneName(zone.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());
|
|
if (vm != null) {
|
|
ipResponse.setVirtualMachineId(vm.getUuid());
|
|
ipResponse.setVirtualMachineName(vm.getHostName());
|
|
if (vm.getDisplayName() != null) {
|
|
ipResponse.setVirtualMachineDisplayName(vm.getDisplayName());
|
|
} else {
|
|
ipResponse.setVirtualMachineDisplayName(vm.getHostName());
|
|
}
|
|
}
|
|
}
|
|
if (ipAddr.getVmIp() != null) {
|
|
ipResponse.setVirtualMachineIp(ipAddr.getVmIp());
|
|
}
|
|
|
|
if (ipAddr.getAssociatedWithNetworkId() != null) {
|
|
Network ntwk = ApiDBUtils.findNetworkById(ipAddr.getAssociatedWithNetworkId());
|
|
if (ntwk != null) {
|
|
ipResponse.setAssociatedNetworkId(ntwk.getUuid());
|
|
ipResponse.setAssociatedNetworkName(ntwk.getName());
|
|
}
|
|
}
|
|
|
|
if (ipAddr.getVpcId() != null) {
|
|
Vpc vpc = ApiDBUtils.findVpcById(ipAddr.getVpcId());
|
|
if (vpc != null) {
|
|
ipResponse.setVpcId(vpc.getUuid());
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
|
|
if (networkId != null) {
|
|
NetworkVO nw = ApiDBUtils.findNetworkById(networkId);
|
|
if (nw != null) {
|
|
ipResponse.setNetworkId(nw.getUuid());
|
|
}
|
|
}
|
|
ipResponse.setState(ipAddr.getState().toString());
|
|
|
|
if (ipAddr.getPhysicalNetworkId() != null) {
|
|
PhysicalNetworkVO pnw = ApiDBUtils.findPhysicalNetworkById(ipAddr.getPhysicalNetworkId());
|
|
if (pnw != null) {
|
|
ipResponse.setPhysicalNetworkId(pnw.getUuid());
|
|
}
|
|
}
|
|
|
|
// show this info to full view only
|
|
if (view == ResponseView.Full) {
|
|
VlanVO vl = ApiDBUtils.findVlanById(ipAddr.getVlanId());
|
|
if (vl != null) {
|
|
ipResponse.setVlanId(vl.getUuid());
|
|
ipResponse.setVlanName(vl.getVlanTag());
|
|
}
|
|
}
|
|
|
|
if (ipAddr.getSystem()) {
|
|
if (ipAddr.isOneToOneNat()) {
|
|
ipResponse.setPurpose(IpAddress.Purpose.StaticNat.toString());
|
|
} else {
|
|
ipResponse.setPurpose(IpAddress.Purpose.Lb.toString());
|
|
}
|
|
}
|
|
|
|
ipResponse.setForDisplay(ipAddr.isDisplay());
|
|
|
|
ipResponse.setPortable(ipAddr.isPortable());
|
|
|
|
//set tag information
|
|
List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(ResourceObjectType.PublicIpAddress, ipAddr.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses, tagResponse);
|
|
}
|
|
ipResponse.setTags(tagResponses);
|
|
|
|
ipResponse.setObjectName("ipaddress");
|
|
return ipResponse;
|
|
}
|
|
|
|
@Override
|
|
public LoadBalancerResponse createLoadBalancerResponse(LoadBalancer loadBalancer) {
|
|
LoadBalancerResponse lbResponse = new LoadBalancerResponse();
|
|
lbResponse.setId(loadBalancer.getUuid());
|
|
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.getUuid());
|
|
lbResponse.setPublicIp(publicIp.getAddress().addr());
|
|
lbResponse.setPublicPort(Integer.toString(loadBalancer.getSourcePortStart()));
|
|
lbResponse.setPrivatePort(Integer.toString(loadBalancer.getDefaultPortStart()));
|
|
lbResponse.setAlgorithm(loadBalancer.getAlgorithm());
|
|
lbResponse.setLbProtocol(loadBalancer.getLbProtocol());
|
|
lbResponse.setForDisplay(loadBalancer.isDisplay());
|
|
FirewallRule.State state = loadBalancer.getState();
|
|
String stateToSet = state.toString();
|
|
if (state.equals(FirewallRule.State.Revoke)) {
|
|
stateToSet = "Deleting";
|
|
}
|
|
lbResponse.setState(stateToSet);
|
|
populateOwner(lbResponse, loadBalancer);
|
|
DataCenter zone = ApiDBUtils.findZoneById(publicIp.getDataCenterId());
|
|
if (zone != null) {
|
|
lbResponse.setZoneId(zone.getUuid());
|
|
lbResponse.setZoneName(zone.getName());
|
|
}
|
|
|
|
//set tag information
|
|
List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(ResourceObjectType.LoadBalancer, loadBalancer.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses, tagResponse);
|
|
}
|
|
lbResponse.setTags(tagResponses);
|
|
|
|
Network ntwk = ApiDBUtils.findNetworkById(loadBalancer.getNetworkId());
|
|
lbResponse.setNetworkId(ntwk.getUuid());
|
|
|
|
lbResponse.setObjectName("loadbalancer");
|
|
return lbResponse;
|
|
}
|
|
|
|
@Override
|
|
public GlobalLoadBalancerResponse createGlobalLoadBalancerResponse(GlobalLoadBalancerRule globalLoadBalancerRule) {
|
|
GlobalLoadBalancerResponse response = new GlobalLoadBalancerResponse();
|
|
response.setAlgorithm(globalLoadBalancerRule.getAlgorithm());
|
|
response.setStickyMethod(globalLoadBalancerRule.getPersistence());
|
|
response.setServiceType(globalLoadBalancerRule.getServiceType());
|
|
response.setServiceDomainName(globalLoadBalancerRule.getGslbDomain() + "." + ApiDBUtils.getDnsNameConfiguredForGslb());
|
|
response.setName(globalLoadBalancerRule.getName());
|
|
response.setDescription(globalLoadBalancerRule.getDescription());
|
|
response.setRegionIdId(globalLoadBalancerRule.getRegion());
|
|
response.setId(globalLoadBalancerRule.getUuid());
|
|
populateOwner(response, globalLoadBalancerRule);
|
|
response.setObjectName("globalloadbalancer");
|
|
|
|
List<LoadBalancerResponse> siteLbResponses = new ArrayList<LoadBalancerResponse>();
|
|
List<? extends LoadBalancer> siteLoadBalaners = ApiDBUtils.listSiteLoadBalancers(globalLoadBalancerRule.getId());
|
|
for (LoadBalancer siteLb : siteLoadBalaners) {
|
|
LoadBalancerResponse siteLbResponse = createLoadBalancerResponse(siteLb);
|
|
siteLbResponses.add(siteLbResponse);
|
|
}
|
|
response.setSiteLoadBalancers(siteLbResponses);
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public PodResponse createPodResponse(Pod pod, Boolean showCapacities) {
|
|
String[] ipRange = new String[2];
|
|
List<String> startIp = new ArrayList<String>();
|
|
List<String> endIp = new ArrayList<String>();
|
|
List<String> forSystemVms = new ArrayList<String>();
|
|
List<String> vlanIds = new ArrayList<String>();
|
|
|
|
if (pod.getDescription() != null && pod.getDescription().length() > 0) {
|
|
final String[] existingPodIpRanges = pod.getDescription().split(",");
|
|
|
|
for(String podIpRange: existingPodIpRanges) {
|
|
final String[] existingPodIpRange = podIpRange.split("-");
|
|
|
|
startIp.add(((existingPodIpRange.length > 0) && (existingPodIpRange[0] != null)) ? existingPodIpRange[0] : "");
|
|
endIp.add(((existingPodIpRange.length > 1) && (existingPodIpRange[1] != null)) ? existingPodIpRange[1] : "");
|
|
forSystemVms.add((existingPodIpRange.length > 2) && (existingPodIpRange[2] != null) ? existingPodIpRange[2] : "0");
|
|
vlanIds.add((existingPodIpRange.length > 3) &&
|
|
(existingPodIpRange[3] != null && !existingPodIpRange.equals("untagged")) ?
|
|
BroadcastDomainType.Vlan.toUri(existingPodIpRange[3]).toString() :
|
|
BroadcastDomainType.Vlan.toUri(Vlan.UNTAGGED).toString());
|
|
}
|
|
}
|
|
|
|
PodResponse podResponse = new PodResponse();
|
|
podResponse.setId(pod.getUuid());
|
|
podResponse.setName(pod.getName());
|
|
DataCenter zone = ApiDBUtils.findZoneById(pod.getDataCenterId());
|
|
if (zone != null) {
|
|
podResponse.setZoneId(zone.getUuid());
|
|
podResponse.setZoneName(zone.getName());
|
|
}
|
|
podResponse.setNetmask(NetUtils.getCidrNetmask(pod.getCidrSize()));
|
|
podResponse.setStartIp(startIp);
|
|
podResponse.setEndIp(endIp);
|
|
podResponse.setForSystemVms(forSystemVms);
|
|
podResponse.setVlanId(vlanIds);
|
|
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>();
|
|
for (SummedCapacity capacity : capacities) {
|
|
CapacityResponse capacityResponse = new CapacityResponse();
|
|
capacityResponse.setCapacityType(capacity.getCapacityType());
|
|
capacityResponse.setCapacityName(CapacityVO.getCapacityName(capacity.getCapacityType()));
|
|
capacityResponse.setCapacityUsed(capacity.getUsedCapacity() + capacity.getReservedCapacity());
|
|
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(ResponseView view, DataCenter dataCenter, Boolean showCapacities) {
|
|
DataCenterJoinVO vOffering = ApiDBUtils.newDataCenterView(dataCenter);
|
|
return ApiDBUtils.newDataCenterResponse(view, vOffering, showCapacities);
|
|
}
|
|
|
|
public static List<CapacityResponse> getDataCenterCapacityResponse(Long zoneId) {
|
|
List<SummedCapacity> capacities = ApiDBUtils.getCapacityByClusterPodZone(zoneId, null, null);
|
|
Set<CapacityResponse> capacityResponses = new HashSet<CapacityResponse>();
|
|
|
|
for (SummedCapacity capacity : capacities) {
|
|
CapacityResponse capacityResponse = new CapacityResponse();
|
|
capacityResponse.setCapacityType(capacity.getCapacityType());
|
|
capacityResponse.setCapacityName(CapacityVO.getCapacityName(capacity.getCapacityType()));
|
|
capacityResponse.setCapacityUsed(capacity.getUsedCapacity() + capacity.getReservedCapacity());
|
|
if (capacity.getCapacityType() == Capacity.CAPACITY_TYPE_STORAGE_ALLOCATED) {
|
|
List<SummedCapacity> c = ApiDBUtils.findNonSharedStorageForClusterPodZone(zoneId, 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, zoneId));
|
|
|
|
return new ArrayList<CapacityResponse>(capacityResponses);
|
|
}
|
|
|
|
private static 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.setCapacityName(CapacityVO.getCapacityName(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(ResponseView view, Volume volume) {
|
|
List<VolumeJoinVO> viewVrs = ApiDBUtils.newVolumeView(volume);
|
|
List<VolumeResponse> listVrs = ViewResponseHelper.createVolumeResponse(view, viewVrs.toArray(new VolumeJoinVO[viewVrs.size()]));
|
|
assert listVrs != null && listVrs.size() == 1 : "There should be one volume returned";
|
|
return listVrs.get(0);
|
|
}
|
|
|
|
@Override
|
|
public InstanceGroupResponse createInstanceGroupResponse(InstanceGroup group) {
|
|
InstanceGroupJoinVO vgroup = ApiDBUtils.newInstanceGroupView(group);
|
|
return ApiDBUtils.newInstanceGroupResponse(vgroup);
|
|
|
|
}
|
|
|
|
@Override
|
|
public StoragePoolResponse createStoragePoolResponse(StoragePool pool) {
|
|
List<StoragePoolJoinVO> viewPools = ApiDBUtils.newStoragePoolView(pool);
|
|
List<StoragePoolResponse> listPools = ViewResponseHelper.createStoragePoolResponse(viewPools.toArray(new StoragePoolJoinVO[viewPools.size()]));
|
|
assert listPools != null && listPools.size() == 1 : "There should be one storage pool returned";
|
|
return listPools.get(0);
|
|
}
|
|
|
|
@Override
|
|
public ImageStoreResponse createImageStoreResponse(ImageStore os) {
|
|
List<ImageStoreJoinVO> viewStores = ApiDBUtils.newImageStoreView(os);
|
|
List<ImageStoreResponse> listStores = ViewResponseHelper.createImageStoreResponse(viewStores.toArray(new ImageStoreJoinVO[viewStores.size()]));
|
|
assert listStores != null && listStores.size() == 1 : "There should be one image data store returned";
|
|
return listStores.get(0);
|
|
}
|
|
|
|
@Override
|
|
public StoragePoolResponse createStoragePoolForMigrationResponse(StoragePool pool) {
|
|
List<StoragePoolJoinVO> viewPools = ApiDBUtils.newStoragePoolView(pool);
|
|
List<StoragePoolResponse> listPools = ViewResponseHelper.createStoragePoolForMigrationResponse(viewPools.toArray(new StoragePoolJoinVO[viewPools.size()]));
|
|
assert listPools != null && listPools.size() == 1 : "There should be one storage pool returned";
|
|
return listPools.get(0);
|
|
}
|
|
|
|
@Override
|
|
public ClusterResponse createClusterResponse(Cluster cluster, Boolean showCapacities) {
|
|
ClusterResponse clusterResponse = new ClusterResponse();
|
|
clusterResponse.setId(cluster.getUuid());
|
|
clusterResponse.setName(cluster.getName());
|
|
HostPodVO pod = ApiDBUtils.findPodById(cluster.getPodId());
|
|
if (pod != null) {
|
|
clusterResponse.setPodId(pod.getUuid());
|
|
clusterResponse.setPodName(pod.getName());
|
|
}
|
|
DataCenter dc = ApiDBUtils.findZoneById(cluster.getDataCenterId());
|
|
if (dc != null) {
|
|
clusterResponse.setZoneId(dc.getUuid());
|
|
clusterResponse.setZoneName(dc.getName());
|
|
}
|
|
clusterResponse.setHypervisorType(cluster.getHypervisorType().toString());
|
|
clusterResponse.setClusterType(cluster.getClusterType().toString());
|
|
clusterResponse.setAllocationState(cluster.getAllocationState().toString());
|
|
clusterResponse.setManagedState(cluster.getManagedState().toString());
|
|
String cpuOvercommitRatio = ApiDBUtils.findClusterDetails(cluster.getId(), "cpuOvercommitRatio");
|
|
String memoryOvercommitRatio = ApiDBUtils.findClusterDetails(cluster.getId(), "memoryOvercommitRatio");
|
|
clusterResponse.setCpuOvercommitRatio(cpuOvercommitRatio);
|
|
clusterResponse.setMemoryOvercommitRatio(memoryOvercommitRatio);
|
|
clusterResponse.setResourceDetails(_clusterDetailsDao.findDetails(cluster.getId()));
|
|
|
|
if (showCapacities != null && showCapacities) {
|
|
List<SummedCapacity> capacities = ApiDBUtils.getCapacityByClusterPodZone(null, null, cluster.getId());
|
|
Set<CapacityResponse> capacityResponses = new HashSet<CapacityResponse>();
|
|
|
|
for (SummedCapacity capacity : capacities) {
|
|
CapacityResponse capacityResponse = new CapacityResponse();
|
|
capacityResponse.setCapacityType(capacity.getCapacityType());
|
|
capacityResponse.setCapacityName(CapacityVO.getCapacityName(capacity.getCapacityType()));
|
|
capacityResponse.setCapacityUsed(capacity.getUsedCapacity() + capacity.getReservedCapacity());
|
|
|
|
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.getUuid());
|
|
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, ","));
|
|
|
|
Network guestNtwk = ApiDBUtils.findNetworkById(fwRule.getNetworkId());
|
|
response.setNetworkId(guestNtwk.getUuid());
|
|
|
|
|
|
IpAddress ip = ApiDBUtils.findIpAddressById(fwRule.getSourceIpAddressId());
|
|
|
|
if (ip != null)
|
|
{
|
|
response.setPublicIpAddressId(ip.getUuid());
|
|
response.setPublicIpAddress(ip.getAddress().addr());
|
|
if (fwRule.getDestinationIpAddress() != null)
|
|
{
|
|
response.setDestNatVmIp(fwRule.getDestinationIpAddress().toString());
|
|
UserVm vm = ApiDBUtils.findUserVmById(fwRule.getVirtualMachineId());
|
|
if (vm != null) {
|
|
response.setVirtualMachineId(vm.getUuid());
|
|
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(ResourceObjectType.PortForwardingRule, fwRule.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses, tagResponse);
|
|
}
|
|
response.setTags(tagResponses);
|
|
|
|
response.setState(stateToSet);
|
|
response.setForDisplay(fwRule.isDisplay());
|
|
response.setObjectName("portforwardingrule");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public IpForwardingRuleResponse createIpForwardingRuleResponse(StaticNatRule fwRule) {
|
|
IpForwardingRuleResponse response = new IpForwardingRuleResponse();
|
|
response.setId(fwRule.getUuid());
|
|
response.setProtocol(fwRule.getProtocol());
|
|
|
|
IpAddress ip = ApiDBUtils.findIpAddressById(fwRule.getSourceIpAddressId());
|
|
|
|
if (ip != null) {
|
|
response.setPublicIpAddressId(ip.getId());
|
|
response.setPublicIpAddress(ip.getAddress().addr());
|
|
if (fwRule.getDestIpAddress() != null) {
|
|
UserVm vm = ApiDBUtils.findUserVmById(ip.getAssociatedWithVmId());
|
|
if (vm != null) {// vm might be destroyed
|
|
response.setVirtualMachineId(vm.getUuid());
|
|
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, UserVm... userVms) {
|
|
return createUserVmResponse(null, objectName, userVms);
|
|
}
|
|
|
|
@Override
|
|
public List<UserVmResponse> createUserVmResponse(String objectName, EnumSet<VMDetails> details, UserVm... userVms) {
|
|
return createUserVmResponse(null, objectName, userVms);
|
|
}
|
|
*/
|
|
|
|
@Override
|
|
public List<UserVmResponse> createUserVmResponse(ResponseView view, String objectName, EnumSet<VMDetails> details, UserVm... userVms) {
|
|
List<UserVmJoinVO> viewVms = ApiDBUtils.newUserVmView(userVms);
|
|
return ViewResponseHelper.createUserVmResponse(view, objectName, details, viewVms.toArray(new UserVmJoinVO[viewVms.size()]));
|
|
|
|
}
|
|
|
|
@Override
|
|
public List<UserVmResponse> createUserVmResponse(ResponseView view, String objectName, UserVm... userVms) {
|
|
List<UserVmJoinVO> viewVms = ApiDBUtils.newUserVmView(userVms);
|
|
return ViewResponseHelper.createUserVmResponse(view, objectName, viewVms.toArray(new UserVmJoinVO[viewVms.size()]));
|
|
}
|
|
|
|
@Override
|
|
public DomainRouterResponse createDomainRouterResponse(VirtualRouter router) {
|
|
List<DomainRouterJoinVO> viewVrs = ApiDBUtils.newDomainRouterView(router);
|
|
List<DomainRouterResponse> listVrs = ViewResponseHelper.createDomainRouterResponse(viewVrs.toArray(new DomainRouterJoinVO[viewVrs.size()]));
|
|
assert listVrs != null && listVrs.size() == 1 : "There should be one virtual router returned";
|
|
return listVrs.get(0);
|
|
}
|
|
|
|
@Override
|
|
public SystemVmResponse createSystemVmResponse(VirtualMachine vm) {
|
|
SystemVmResponse vmResponse = new SystemVmResponse();
|
|
if (vm.getType() == Type.SecondaryStorageVm || vm.getType() == Type.ConsoleProxy || vm.getType() == Type.DomainRouter || vm.getType() == Type.NetScalerVm) {
|
|
vmResponse.setId(vm.getUuid());
|
|
vmResponse.setSystemVmType(vm.getType().toString().toLowerCase());
|
|
vmResponse.setName(vm.getHostName());
|
|
|
|
if (vm.getPodIdToDeployIn() != null) {
|
|
HostPodVO pod = ApiDBUtils.findPodById(vm.getPodIdToDeployIn());
|
|
if (pod != null) {
|
|
vmResponse.setPodId(pod.getUuid());
|
|
}
|
|
}
|
|
VMTemplateVO template = ApiDBUtils.findTemplateById(vm.getTemplateId());
|
|
if (template != null) {
|
|
vmResponse.setTemplateId(template.getUuid());
|
|
}
|
|
vmResponse.setCreated(vm.getCreated());
|
|
|
|
if (vm.getHostId() != null) {
|
|
Host host = ApiDBUtils.findHostById(vm.getHostId());
|
|
if (host != null) {
|
|
vmResponse.setHostId(host.getUuid());
|
|
vmResponse.setHostName(host.getName());
|
|
vmResponse.setHypervisor(host.getHypervisorType().toString());
|
|
}
|
|
}
|
|
|
|
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.getDataCenterId());
|
|
if (zone != null) {
|
|
vmResponse.setZoneId(zone.getUuid());
|
|
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.getIPv4Address());
|
|
vmResponse.setPrivateMacAddress(singleNicProfile.getMacAddress());
|
|
vmResponse.setPrivateNetmask(singleNicProfile.getIPv4Netmask());
|
|
} else if (network.getTrafficType() == TrafficType.Control) {
|
|
vmResponse.setLinkLocalIp(singleNicProfile.getIPv4Address());
|
|
vmResponse.setLinkLocalMacAddress(singleNicProfile.getMacAddress());
|
|
vmResponse.setLinkLocalNetmask(singleNicProfile.getIPv4Netmask());
|
|
} else if (network.getTrafficType() == TrafficType.Public) {
|
|
vmResponse.setPublicIp(singleNicProfile.getIPv4Address());
|
|
vmResponse.setPublicMacAddress(singleNicProfile.getMacAddress());
|
|
vmResponse.setPublicNetmask(singleNicProfile.getIPv4Netmask());
|
|
vmResponse.setGateway(singleNicProfile.getIPv4Gateway());
|
|
} else if (network.getTrafficType() == TrafficType.Guest) {
|
|
/*
|
|
* In basic zone, public ip has TrafficType.Guest in case EIP service is not enabled.
|
|
* When EIP service is enabled in the basic zone, system VM by default get the public
|
|
* IP allocated for EIP. So return the guest/public IP accordingly.
|
|
* */
|
|
NetworkOffering networkOffering = ApiDBUtils.findNetworkOfferingById(network.getNetworkOfferingId());
|
|
if (networkOffering.getElasticIp()) {
|
|
IpAddress ip = ApiDBUtils.findIpByAssociatedVmId(vm.getId());
|
|
if (ip != null) {
|
|
Vlan vlan = ApiDBUtils.findVlanById(ip.getVlanId());
|
|
vmResponse.setPublicIp(ip.getAddress().addr());
|
|
vmResponse.setPublicNetmask(vlan.getVlanNetmask());
|
|
vmResponse.setGateway(vlan.getVlanGateway());
|
|
}
|
|
} else {
|
|
vmResponse.setPublicIp(singleNicProfile.getIPv4Address());
|
|
vmResponse.setPublicMacAddress(singleNicProfile.getMacAddress());
|
|
vmResponse.setPublicNetmask(singleNicProfile.getIPv4Netmask());
|
|
vmResponse.setGateway(singleNicProfile.getIPv4Gateway());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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 DiskOfferingVO findDiskOfferingById(Long diskOfferingId) {
|
|
return ApiDBUtils.findDiskOfferingById(diskOfferingId);
|
|
}
|
|
|
|
@Override
|
|
public VpnUsersResponse createVpnUserResponse(VpnUser vpnUser) {
|
|
VpnUsersResponse vpnResponse = new VpnUsersResponse();
|
|
vpnResponse.setId(vpnUser.getUuid());
|
|
vpnResponse.setUserName(vpnUser.getUsername());
|
|
vpnResponse.setState(vpnUser.getState().toString());
|
|
|
|
populateOwner(vpnResponse, vpnUser);
|
|
|
|
vpnResponse.setObjectName("vpnuser");
|
|
return vpnResponse;
|
|
}
|
|
|
|
@Override
|
|
public RemoteAccessVpnResponse createRemoteAccessVpnResponse(RemoteAccessVpn vpn) {
|
|
RemoteAccessVpnResponse vpnResponse = new RemoteAccessVpnResponse();
|
|
IpAddress ip = ApiDBUtils.findIpAddressById(vpn.getServerAddressId());
|
|
if (ip != null) {
|
|
vpnResponse.setPublicIpId(ip.getUuid());
|
|
vpnResponse.setPublicIp(ip.getAddress().addr());
|
|
}
|
|
vpnResponse.setIpRange(vpn.getIpRange());
|
|
vpnResponse.setPresharedKey(vpn.getIpsecPresharedKey());
|
|
populateOwner(vpnResponse, vpn);
|
|
vpnResponse.setState(vpn.getState().toString());
|
|
vpnResponse.setId(vpn.getUuid());
|
|
vpnResponse.setForDisplay(vpn.isDisplay());
|
|
vpnResponse.setObjectName("remoteaccessvpn");
|
|
|
|
return vpnResponse;
|
|
}
|
|
|
|
@Override
|
|
public TemplateResponse createTemplateUpdateResponse(ResponseView view, VirtualMachineTemplate result) {
|
|
List<TemplateJoinVO> tvo = ApiDBUtils.newTemplateView(result);
|
|
List<TemplateResponse> listVrs = ViewResponseHelper.createTemplateUpdateResponse(view, tvo.toArray(new TemplateJoinVO[tvo.size()]));
|
|
assert listVrs != null && listVrs.size() == 1 : "There should be one template returned";
|
|
return listVrs.get(0);
|
|
}
|
|
|
|
@Override
|
|
public List<TemplateResponse> createTemplateResponses(ResponseView view, VirtualMachineTemplate result, Long zoneId, boolean readyOnly) {
|
|
List<TemplateJoinVO> tvo = null;
|
|
if (zoneId == null || zoneId == -1 || result.isCrossZones()) {
|
|
tvo = ApiDBUtils.newTemplateView(result);
|
|
} else {
|
|
tvo = ApiDBUtils.newTemplateView(result, zoneId, readyOnly);
|
|
|
|
}
|
|
return ViewResponseHelper.createTemplateResponse(view, tvo.toArray(new TemplateJoinVO[tvo.size()]));
|
|
}
|
|
|
|
@Override
|
|
public List<TemplateResponse> createTemplateResponses(ResponseView view, VirtualMachineTemplate result,
|
|
List<Long> zoneIds, boolean readyOnly) {
|
|
List<TemplateJoinVO> tvo = null;
|
|
if (zoneIds == null) {
|
|
return createTemplateResponses(view, result, (Long)null, readyOnly);
|
|
} else {
|
|
for (Long zoneId: zoneIds){
|
|
if (tvo == null)
|
|
tvo = ApiDBUtils.newTemplateView(result, zoneId, readyOnly);
|
|
else
|
|
tvo.addAll(ApiDBUtils.newTemplateView(result, zoneId, readyOnly));
|
|
}
|
|
}
|
|
return ViewResponseHelper.createTemplateResponse(view, tvo.toArray(new TemplateJoinVO[tvo.size()]));
|
|
}
|
|
|
|
@Override
|
|
public List<TemplateResponse> createTemplateResponses(ResponseView view, long templateId, Long zoneId, boolean readyOnly) {
|
|
VirtualMachineTemplate template = findTemplateById(templateId);
|
|
return createTemplateResponses(view, template, zoneId, readyOnly);
|
|
}
|
|
|
|
@Override
|
|
public List<TemplateResponse> createIsoResponses(ResponseView view, VirtualMachineTemplate result, Long zoneId, boolean readyOnly) {
|
|
List<TemplateJoinVO> tvo = null;
|
|
if (zoneId == null || zoneId == -1) {
|
|
tvo = ApiDBUtils.newTemplateView(result);
|
|
} else {
|
|
tvo = ApiDBUtils.newTemplateView(result, zoneId, readyOnly);
|
|
}
|
|
|
|
return ViewResponseHelper.createIsoResponse(view, tvo.toArray(new TemplateJoinVO[tvo.size()]));
|
|
}
|
|
|
|
@Override
|
|
public SecurityGroupResponse createSecurityGroupResponse(SecurityGroup group) {
|
|
List<SecurityGroupJoinVO> viewSgs = ApiDBUtils.newSecurityGroupView(group);
|
|
List<SecurityGroupResponse> listSgs = ViewResponseHelper.createSecurityGroupResponses(viewSgs);
|
|
assert listSgs != null && listSgs.size() == 1 : "There should be one security group returned";
|
|
return listSgs.get(0);
|
|
}
|
|
|
|
//TODO: we need to deprecate uploadVO, since extract is done in a synchronous fashion
|
|
@Override
|
|
public ExtractResponse createExtractResponse(Long id, Long zoneId, Long accountId, String mode, String url) {
|
|
|
|
ExtractResponse response = new ExtractResponse();
|
|
response.setObjectName("template");
|
|
VMTemplateVO template = ApiDBUtils.findTemplateById(id);
|
|
response.setId(template.getUuid());
|
|
response.setName(template.getName());
|
|
if (zoneId != null) {
|
|
DataCenter zone = ApiDBUtils.findZoneById(zoneId);
|
|
response.setZoneId(zone.getUuid());
|
|
response.setZoneName(zone.getName());
|
|
}
|
|
response.setMode(mode);
|
|
response.setUrl(url);
|
|
response.setState(Upload.Status.DOWNLOAD_URL_CREATED.toString());
|
|
Account account = ApiDBUtils.findAccountById(accountId);
|
|
response.setAccountId(account.getUuid());
|
|
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public ExtractResponse createExtractResponse(Long uploadId, Long id, Long zoneId, Long accountId, String mode, String url) {
|
|
|
|
ExtractResponse response = new ExtractResponse();
|
|
response.setObjectName("template");
|
|
VMTemplateVO template = ApiDBUtils.findTemplateById(id);
|
|
response.setId(template.getUuid());
|
|
response.setName(template.getName());
|
|
if (zoneId != null) {
|
|
DataCenter zone = ApiDBUtils.findZoneById(zoneId);
|
|
response.setZoneId(zone.getUuid());
|
|
response.setZoneName(zone.getName());
|
|
}
|
|
response.setMode(mode);
|
|
if (uploadId == null) {
|
|
// region-wide image store
|
|
response.setUrl(url);
|
|
response.setState(Upload.Status.DOWNLOAD_URL_CREATED.toString());
|
|
} else {
|
|
UploadVO uploadInfo = ApiDBUtils.findUploadById(uploadId);
|
|
response.setUploadId(uploadInfo.getUuid());
|
|
response.setState(uploadInfo.getUploadState().toString());
|
|
response.setUrl(uploadInfo.getUploadUrl());
|
|
}
|
|
Account account = ApiDBUtils.findAccountById(accountId);
|
|
response.setAccountId(account.getUuid());
|
|
|
|
return response;
|
|
|
|
}
|
|
|
|
@Override
|
|
public String toSerializedString(CreateCmdResponse response, String responseType) {
|
|
return ApiResponseSerializer.toSerializedString(response, responseType);
|
|
}
|
|
|
|
@Override
|
|
public List<TemplateResponse> createTemplateResponses(ResponseView view, long templateId, Long snapshotId, Long volumeId, boolean readyOnly) {
|
|
Long zoneId = null;
|
|
|
|
if (snapshotId != null) {
|
|
Snapshot snapshot = ApiDBUtils.findSnapshotById(snapshotId);
|
|
VolumeVO volume = findVolumeById(snapshot.getVolumeId());
|
|
|
|
// it seems that the volume can actually be removed from the DB at some point if it's deleted
|
|
// if volume comes back null, use another technique to try to discover the zone
|
|
if (volume == null) {
|
|
SnapshotDataStoreVO snapshotStore = _snapshotStoreDao.findBySnapshot(snapshot.getId(), DataStoreRole.Primary);
|
|
|
|
if (snapshotStore != null) {
|
|
long storagePoolId = snapshotStore.getDataStoreId();
|
|
|
|
StoragePoolVO storagePool = _storagePoolDao.findById(storagePoolId);
|
|
|
|
if (storagePool != null) {
|
|
zoneId = storagePool.getDataCenterId();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
zoneId = volume.getDataCenterId();
|
|
}
|
|
} else {
|
|
VolumeVO volume = findVolumeById(volumeId);
|
|
|
|
zoneId = volume.getDataCenterId();
|
|
}
|
|
|
|
if (zoneId == null) {
|
|
throw new CloudRuntimeException("Unable to determine the zone ID");
|
|
}
|
|
|
|
return createTemplateResponses(view, templateId, zoneId, readyOnly);
|
|
}
|
|
|
|
@Override
|
|
public List<TemplateResponse> createTemplateResponses(ResponseView view, long templateId, Long vmId) {
|
|
UserVm vm = findUserVmById(vmId);
|
|
Long hostId = (vm.getHostId() == null ? vm.getLastHostId() : vm.getHostId());
|
|
Host host = findHostById(hostId);
|
|
return createTemplateResponses(view, templateId, host.getDataCenterId(), true);
|
|
}
|
|
|
|
@Override
|
|
public EventResponse createEventResponse(Event event) {
|
|
EventJoinVO vEvent = ApiDBUtils.newEventView(event);
|
|
return ApiDBUtils.newEventResponse(vEvent);
|
|
}
|
|
|
|
@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());
|
|
if (summedCapacity.getAllocatedCapacity() != null) {
|
|
capacityResponse.setCapacityAllocated(summedCapacity.getAllocatedCapacity());
|
|
}
|
|
capacityResponse.setCapacityType(summedCapacity.getCapacityType());
|
|
capacityResponse.setCapacityName(CapacityVO.getCapacityName(summedCapacity.getCapacityType()));
|
|
capacityResponse.setCapacityUsed(summedCapacity.getUsedCapacity());
|
|
if (summedCapacity.getPodId() != null) {
|
|
capacityResponse.setPodId(ApiDBUtils.findPodById(summedCapacity.getPodId()).getUuid());
|
|
HostPodVO pod = ApiDBUtils.findPodById(summedCapacity.getPodId());
|
|
if (pod != null) {
|
|
capacityResponse.setPodId(pod.getUuid());
|
|
capacityResponse.setPodName(pod.getName());
|
|
}
|
|
}
|
|
if (summedCapacity.getClusterId() != null) {
|
|
ClusterVO cluster = ApiDBUtils.findClusterById(summedCapacity.getClusterId());
|
|
if (cluster != null) {
|
|
capacityResponse.setClusterId(cluster.getUuid());
|
|
capacityResponse.setClusterName(cluster.getName());
|
|
if (summedCapacity.getPodId() == null) {
|
|
HostPodVO pod = ApiDBUtils.findPodById(cluster.getPodId());
|
|
capacityResponse.setPodId(pod.getUuid());
|
|
capacityResponse.setPodName(pod.getName());
|
|
}
|
|
}
|
|
}
|
|
DataCenter zone = ApiDBUtils.findZoneById(summedCapacity.getDataCenterId());
|
|
if (zone != null) {
|
|
capacityResponse.setZoneId(zone.getUuid());
|
|
capacityResponse.setZoneName(zone.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);
|
|
}
|
|
|
|
List<VgpuTypesInfo> gpuCapacities;
|
|
if (result.size() > 1 && (gpuCapacities = ApiDBUtils.getGpuCapacites(result.get(0).getDataCenterId(), result.get(0).getPodId(), result.get(0).getClusterId())) != null) {
|
|
HashMap<String, Long> vgpuVMs = ApiDBUtils.getVgpuVmsCount(result.get(0).getDataCenterId(), result.get(0).getPodId(), result.get(0).getClusterId());
|
|
|
|
float capacityUsed = 0;
|
|
long capacityMax = 0;
|
|
for (VgpuTypesInfo capacity : gpuCapacities) {
|
|
if (vgpuVMs.containsKey(capacity.getGroupName().concat(capacity.getModelName()))) {
|
|
capacityUsed += (float)vgpuVMs.get(capacity.getGroupName().concat(capacity.getModelName())) / capacity.getMaxVpuPerGpu();
|
|
}
|
|
if (capacity.getModelName().equals(GPU.GPUType.passthrough.toString())) {
|
|
capacityMax += capacity.getMaxCapacity();
|
|
}
|
|
}
|
|
|
|
DataCenter zone = ApiDBUtils.findZoneById(result.get(0).getDataCenterId());
|
|
CapacityResponse capacityResponse = new CapacityResponse();
|
|
if (zone != null) {
|
|
capacityResponse.setZoneId(zone.getUuid());
|
|
capacityResponse.setZoneName(zone.getName());
|
|
}
|
|
if (result.get(0).getPodId() != null) {
|
|
HostPodVO pod = ApiDBUtils.findPodById(result.get(0).getPodId());
|
|
capacityResponse.setPodId(pod.getUuid());
|
|
capacityResponse.setPodName(pod.getName());
|
|
}
|
|
if (result.get(0).getClusterId() != null) {
|
|
ClusterVO cluster = ApiDBUtils.findClusterById(result.get(0).getClusterId());
|
|
capacityResponse.setClusterId(cluster.getUuid());
|
|
capacityResponse.setClusterName(cluster.getName());
|
|
}
|
|
capacityResponse.setCapacityType(Capacity.CAPACITY_TYPE_GPU);
|
|
capacityResponse.setCapacityName(CapacityVO.getCapacityName(Capacity.CAPACITY_TYPE_GPU));
|
|
capacityResponse.setCapacityUsed((long)Math.ceil(capacityUsed));
|
|
capacityResponse.setCapacityTotal(capacityMax);
|
|
if (capacityMax > 0) {
|
|
capacityResponse.setPercentUsed(format.format(capacityUsed / capacityMax * 100f));
|
|
} else {
|
|
capacityResponse.setPercentUsed(format.format(0));
|
|
}
|
|
capacityResponse.setObjectName("capacity");
|
|
capacityResponses.add(capacityResponse);
|
|
}
|
|
return capacityResponses;
|
|
}
|
|
|
|
@Override
|
|
public TemplatePermissionsResponse createTemplatePermissionsResponse(ResponseView view, List<String> accountNames, Long id) {
|
|
Long templateOwnerDomain = null;
|
|
VirtualMachineTemplate template = ApiDBUtils.findTemplateById(id);
|
|
Account templateOwner = ApiDBUtils.findAccountById(template.getAccountId());
|
|
if (view == ResponseView.Full) {
|
|
// 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.getUuid());
|
|
response.setPublicTemplate(template.isPublicTemplate());
|
|
if ((view == ResponseView.Full) && (templateOwnerDomain != null)) {
|
|
Domain domain = ApiDBUtils.findDomainById(templateOwnerDomain);
|
|
if (domain != null) {
|
|
response.setDomainId(domain.getUuid());
|
|
}
|
|
}
|
|
|
|
// 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.findProjectByProjectAccountId(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) {
|
|
Account caller = CallContext.current().getCallingAccount();
|
|
|
|
AsyncJob job = _entityMgr.findById(AsyncJob.class, cmd.getId());
|
|
if (job == null) {
|
|
throw new InvalidParameterValueException("Unable to find a job by id " + cmd.getId());
|
|
}
|
|
|
|
User userJobOwner = _accountMgr.getUserIncludingRemoved(job.getUserId());
|
|
Account jobOwner = _accountMgr.getAccount(userJobOwner.getAccountId());
|
|
|
|
//check permissions
|
|
if (_accountMgr.isNormalUser(caller.getId())) {
|
|
//regular user can see only jobs he owns
|
|
if (caller.getId() != jobOwner.getId()) {
|
|
throw new PermissionDeniedException("Account " + caller + " is not authorized to see job id=" + job.getId());
|
|
}
|
|
} else if (_accountMgr.isDomainAdmin(caller.getId())) {
|
|
_accountMgr.checkAccess(caller, null, true, jobOwner);
|
|
}
|
|
|
|
return createAsyncJobResponse(_jobMgr.queryJob(cmd.getId(), true));
|
|
}
|
|
|
|
public AsyncJobResponse createAsyncJobResponse(AsyncJob job) {
|
|
AsyncJobJoinVO vJob = ApiDBUtils.newAsyncJobView(job);
|
|
return ApiDBUtils.newAsyncJobResponse(vJob);
|
|
}
|
|
|
|
@Override
|
|
public SecurityGroupResponse createSecurityGroupResponseFromSecurityGroupRule(List<? extends SecurityRule> securityRules) {
|
|
SecurityGroupResponse response = new SecurityGroupResponse();
|
|
Map<Long, Account> securiytGroupAccounts = new HashMap<Long, Account>();
|
|
|
|
if ((securityRules != null) && !securityRules.isEmpty()) {
|
|
SecurityGroupJoinVO securityGroup = ApiDBUtils.findSecurityGroupViewById(securityRules.get(0).getSecurityGroupId()).get(0);
|
|
response.setId(securityGroup.getUuid());
|
|
response.setName(securityGroup.getName());
|
|
response.setDescription(securityGroup.getDescription());
|
|
|
|
Account account = securiytGroupAccounts.get(securityGroup.getAccountId());
|
|
|
|
if (securityGroup.getAccountType() == Account.ACCOUNT_TYPE_PROJECT) {
|
|
response.setProjectId(securityGroup.getProjectUuid());
|
|
response.setProjectName(securityGroup.getProjectName());
|
|
} else {
|
|
response.setAccountName(securityGroup.getAccountName());
|
|
}
|
|
|
|
response.setDomainId(securityGroup.getDomainUuid());
|
|
response.setDomainName(securityGroup.getDomainName());
|
|
|
|
for (SecurityRule securityRule : securityRules) {
|
|
SecurityGroupRuleResponse securityGroupData = new SecurityGroupRuleResponse();
|
|
|
|
securityGroupData.setRuleId(securityRule.getUuid());
|
|
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) {
|
|
List<SecurityGroupJoinVO> sgs = ApiDBUtils.findSecurityGroupViewById(allowedSecurityGroupId);
|
|
if (sgs != null && sgs.size() > 0) {
|
|
SecurityGroupJoinVO sg = sgs.get(0);
|
|
securityGroupData.setSecurityGroupName(sg.getName());
|
|
securityGroupData.setAccountName(sg.getAccountName());
|
|
}
|
|
} else {
|
|
securityGroupData.setCidr(securityRule.getAllowedSourceIpCidr());
|
|
}
|
|
if (securityRule.getRuleType() == SecurityRuleType.IngressRule) {
|
|
securityGroupData.setObjectName("ingressrule");
|
|
response.addSecurityGroupIngressRule(securityGroupData);
|
|
} else {
|
|
securityGroupData.setObjectName("egressrule");
|
|
response.addSecurityGroupEgressRule(securityGroupData);
|
|
}
|
|
|
|
}
|
|
response.setObjectName("securitygroup");
|
|
|
|
}
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public NetworkOfferingResponse createNetworkOfferingResponse(NetworkOffering offering) {
|
|
NetworkOfferingResponse response = new NetworkOfferingResponse();
|
|
response.setId(offering.getUuid());
|
|
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.setIsPersistent(offering.getIsPersistent());
|
|
response.setNetworkRate(ApiDBUtils.getNetworkRate(offering.getId()));
|
|
response.setEgressDefaultPolicy(offering.getEgressDefaultPolicy());
|
|
response.setConcurrentConnections(offering.getConcurrentConnections());
|
|
response.setSupportsStrechedL2Subnet(offering.getSupportsStrechedL2());
|
|
response.setSupportsPublicAccess(offering.getSupportsPublicAccess());
|
|
Long so = null;
|
|
if (offering.getServiceOfferingId() != null) {
|
|
so = offering.getServiceOfferingId();
|
|
} else {
|
|
so = ApiDBUtils.findDefaultRouterServiceOffering();
|
|
}
|
|
if (so != null) {
|
|
ServiceOffering soffering = ApiDBUtils.findServiceOfferingById(so);
|
|
if (soffering != null) {
|
|
response.setServiceOfferingId(soffering.getUuid());
|
|
}
|
|
}
|
|
|
|
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 (Map.Entry<Service,Set<Provider>> entry : serviceProviderMap.entrySet()) {
|
|
Service service = entry.getKey();
|
|
Set<Provider> srvc_providers = entry.getValue();
|
|
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 : srvc_providers) {
|
|
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);
|
|
|
|
CapabilityResponse inline = new CapabilityResponse();
|
|
inline.setName(Capability.InlineMode.getName());
|
|
inline.setValue(offering.isInline() ? "true" : "false");
|
|
lbCapResponse.add(inline);
|
|
|
|
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.getElasticIp() ? "true" : "false");
|
|
staticNatCapResponse.add(eIp);
|
|
|
|
CapabilityResponse associatePublicIp = new CapabilityResponse();
|
|
associatePublicIp.setName(Capability.AssociatePublicIP.getName());
|
|
associatePublicIp.setValue(offering.getAssociatePublicIP() ? "true" : "false");
|
|
staticNatCapResponse.add(associatePublicIp);
|
|
|
|
svcRsp.setCapabilities(staticNatCapResponse);
|
|
}
|
|
|
|
serviceResponses.add(svcRsp);
|
|
}
|
|
response.setForVpc(_configMgr.isOfferingForVpc(offering));
|
|
|
|
response.setServices(serviceResponses);
|
|
|
|
//set network offering details
|
|
Map<Detail, String> details = _ntwkModel.getNtwkOffDetails(offering.getId());
|
|
if (details != null && !details.isEmpty()) {
|
|
response.setDetails(details);
|
|
}
|
|
|
|
response.setObjectName("networkoffering");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public NetworkResponse createNetworkResponse(ResponseView view, 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.getUuid());
|
|
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.getNetworkCidr() != null) {
|
|
response.setNetworkCidr((network.getNetworkCidr()));
|
|
}
|
|
// If network has reservation its entire network cidr is defined by
|
|
// getNetworkCidr()
|
|
// if no reservation is present then getCidr() will define the entire
|
|
// network cidr
|
|
if (network.getNetworkCidr() != null) {
|
|
response.setNetmask(NetUtils.cidr2Netmask(network.getNetworkCidr()));
|
|
}
|
|
if (((network.getCidr()) != null) && (network.getNetworkCidr() == null)) {
|
|
response.setNetmask(NetUtils.cidr2Netmask(network.getCidr()));
|
|
}
|
|
|
|
response.setIp6Gateway(network.getIp6Gateway());
|
|
response.setIp6Cidr(network.getIp6Cidr());
|
|
|
|
// create response for reserved IP ranges that can be used for
|
|
// non-cloudstack purposes
|
|
String reservation = null;
|
|
if ((network.getCidr() != null) && (NetUtils.isNetworkAWithinNetworkB(network.getCidr(), network.getNetworkCidr()))) {
|
|
String[] guestVmCidrPair = network.getCidr().split("\\/");
|
|
String[] guestCidrPair = network.getNetworkCidr().split("\\/");
|
|
|
|
Long guestVmCidrSize = Long.valueOf(guestVmCidrPair[1]);
|
|
Long guestCidrSize = Long.valueOf(guestCidrPair[1]);
|
|
|
|
String[] guestVmIpRange = NetUtils.getIpRangeFromCidr(guestVmCidrPair[0], guestVmCidrSize);
|
|
String[] guestIpRange = NetUtils.getIpRangeFromCidr(guestCidrPair[0], guestCidrSize);
|
|
long startGuestIp = NetUtils.ip2Long(guestIpRange[0]);
|
|
long endGuestIp = NetUtils.ip2Long(guestIpRange[1]);
|
|
long startVmIp = NetUtils.ip2Long(guestVmIpRange[0]);
|
|
long endVmIp = NetUtils.ip2Long(guestVmIpRange[1]);
|
|
|
|
if (startVmIp == startGuestIp && endVmIp < endGuestIp - 1) {
|
|
reservation = (NetUtils.long2Ip(endVmIp + 1) + "-" + NetUtils.long2Ip(endGuestIp));
|
|
}
|
|
if (endVmIp == endGuestIp && startVmIp > startGuestIp + 1) {
|
|
reservation = (NetUtils.long2Ip(startGuestIp) + "-" + NetUtils.long2Ip(startVmIp - 1));
|
|
}
|
|
if (startVmIp > startGuestIp + 1 && endVmIp < endGuestIp - 1) {
|
|
reservation = (NetUtils.long2Ip(startGuestIp) + "-" + NetUtils.long2Ip(startVmIp - 1) + " , " + NetUtils.long2Ip(endVmIp + 1) + "-" + NetUtils.long2Ip(endGuestIp));
|
|
}
|
|
}
|
|
response.setReservedIpRange(reservation);
|
|
|
|
// return vlan information only to Root admin
|
|
if (network.getBroadcastUri() != null && view == ResponseView.Full) {
|
|
String broadcastUri = network.getBroadcastUri().toString();
|
|
response.setBroadcastUri(broadcastUri);
|
|
String vlan = "N/A";
|
|
switch (BroadcastDomainType.getSchemeValue(network.getBroadcastUri())) {
|
|
case Vlan:
|
|
case Vxlan:
|
|
vlan = BroadcastDomainType.getValue(network.getBroadcastUri());
|
|
break;
|
|
}
|
|
// return vlan information only to Root admin
|
|
response.setVlan(vlan);
|
|
}
|
|
|
|
DataCenter zone = ApiDBUtils.findZoneById(network.getDataCenterId());
|
|
if (zone != null) {
|
|
response.setZoneId(zone.getUuid());
|
|
response.setZoneName(zone.getName());
|
|
}
|
|
if (network.getPhysicalNetworkId() != null) {
|
|
PhysicalNetworkVO pnet = ApiDBUtils.findPhysicalNetworkById(network.getPhysicalNetworkId());
|
|
response.setPhysicalNetworkId(pnet.getUuid());
|
|
}
|
|
|
|
// populate network offering information
|
|
NetworkOffering networkOffering = ApiDBUtils.findNetworkOfferingById(network.getNetworkOfferingId());
|
|
if (networkOffering != null) {
|
|
response.setNetworkOfferingId(networkOffering.getUuid());
|
|
response.setNetworkOfferingName(networkOffering.getName());
|
|
response.setNetworkOfferingDisplayText(networkOffering.getDisplayText());
|
|
response.setNetworkOfferingConserveMode(networkOffering.isConserveMode());
|
|
response.setIsSystem(networkOffering.isSystemOnly());
|
|
response.setNetworkOfferingAvailability(networkOffering.getAvailability().toString());
|
|
response.setIsPersistent(networkOffering.getIsPersistent());
|
|
}
|
|
|
|
if (network.getAclType() != null) {
|
|
response.setAclType(network.getAclType().toString());
|
|
}
|
|
response.setDisplayNetwork(network.getDisplayNetwork());
|
|
response.setState(network.getState().toString());
|
|
response.setRestartRequired(network.isRestartRequired());
|
|
NetworkVO nw = ApiDBUtils.findNetworkById(network.getRelated());
|
|
if (nw != null) {
|
|
response.setRelated(nw.getUuid());
|
|
}
|
|
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 (Map.Entry<Service, Map<Capability, String>>entry : serviceCapabilitiesMap.entrySet()) {
|
|
Service service = entry.getKey();
|
|
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 = entry.getValue();
|
|
if (serviceCapabilities != null) {
|
|
for (Map.Entry<Capability,String> ser_cap_entries : serviceCapabilities.entrySet()) {
|
|
Capability capability = ser_cap_entries.getKey();
|
|
CapabilityResponse capabilityResponse = new CapabilityResponse();
|
|
String capabilityValue = ser_cap_entries.getValue();
|
|
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());
|
|
if (domainNetworkDetails.first() != null) {
|
|
Domain domain = ApiDBUtils.findDomainById(domainNetworkDetails.first());
|
|
if (domain != null) {
|
|
response.setDomainId(domain.getUuid());
|
|
}
|
|
}
|
|
response.setSubdomainAccess(domainNetworkDetails.second());
|
|
}
|
|
|
|
Long dedicatedDomainId = ApiDBUtils.getDedicatedNetworkDomain(network.getId());
|
|
if (dedicatedDomainId != null) {
|
|
Domain domain = ApiDBUtils.findDomainById(dedicatedDomainId);
|
|
if (domain != null) {
|
|
response.setDomainId(domain.getUuid());
|
|
response.setDomainName(domain.getName());
|
|
}
|
|
|
|
}
|
|
|
|
response.setSpecifyIpRanges(network.getSpecifyIpRanges());
|
|
if (network.getVpcId() != null) {
|
|
Vpc vpc = ApiDBUtils.findVpcById(network.getVpcId());
|
|
if (vpc != null) {
|
|
response.setVpcId(vpc.getUuid());
|
|
}
|
|
}
|
|
response.setCanUseForDeploy(ApiDBUtils.canUseForDeploy(network));
|
|
|
|
// set tag information
|
|
List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(ResourceObjectType.Network, network.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses, tagResponse);
|
|
}
|
|
response.setTags(tagResponses);
|
|
|
|
if (network.getNetworkACLId() != null) {
|
|
NetworkACL acl = ApiDBUtils.findByNetworkACLId(network.getNetworkACLId());
|
|
if (acl != null) {
|
|
response.setAclId(acl.getUuid());
|
|
}
|
|
}
|
|
|
|
response.setStrechedL2Subnet(network.isStrechedL2Network());
|
|
if (network.isStrechedL2Network()) {
|
|
Set<String> networkSpannedZones = new HashSet<String>();
|
|
List<VMInstanceVO> vmInstances = new ArrayList<VMInstanceVO>();
|
|
vmInstances.addAll(ApiDBUtils.listUserVMsByNetworkId(network.getId()));
|
|
vmInstances.addAll(ApiDBUtils.listDomainRoutersByNetworkId(network.getId()));
|
|
for (VirtualMachine vm : vmInstances) {
|
|
DataCenter vmZone = ApiDBUtils.findZoneById(vm.getDataCenterId());
|
|
networkSpannedZones.add(vmZone.getUuid());
|
|
}
|
|
response.setNetworkSpannedZones(networkSpannedZones);
|
|
}
|
|
response.setExternalId(network.getExternalId());
|
|
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) {
|
|
List<ProjectJoinVO> viewPrjs = ApiDBUtils.newProjectView(project);
|
|
List<ProjectResponse> listPrjs = ViewResponseHelper.createProjectResponse(viewPrjs.toArray(new ProjectJoinVO[viewPrjs.size()]));
|
|
assert listPrjs != null && listPrjs.size() == 1 : "There should be one project returned";
|
|
return listPrjs.get(0);
|
|
}
|
|
|
|
@Override
|
|
public FirewallResponse createFirewallResponse(FirewallRule fwRule) {
|
|
FirewallResponse response = new FirewallResponse();
|
|
|
|
response.setId(fwRule.getUuid());
|
|
response.setProtocol(fwRule.getProtocol());
|
|
if (fwRule.getSourcePortStart() != null) {
|
|
response.setStartPort(fwRule.getSourcePortStart());
|
|
}
|
|
|
|
if (fwRule.getSourcePortEnd() != null) {
|
|
response.setEndPort(fwRule.getSourcePortEnd());
|
|
}
|
|
|
|
List<String> cidrs = ApiDBUtils.findFirewallSourceCidrs(fwRule.getId());
|
|
response.setCidrList(StringUtils.join(cidrs, ","));
|
|
|
|
if(fwRule.getTrafficType() == FirewallRule.TrafficType.Egress){
|
|
List<String> destCidrs = ApiDBUtils.findFirewallDestCidrs(fwRule.getId());
|
|
response.setDestCidr(StringUtils.join(destCidrs,","));
|
|
}
|
|
|
|
if (fwRule.getTrafficType() == FirewallRule.TrafficType.Ingress) {
|
|
IpAddress ip = ApiDBUtils.findIpAddressById(fwRule.getSourceIpAddressId());
|
|
response.setPublicIpAddressId(ip.getUuid());
|
|
response.setPublicIpAddress(ip.getAddress().addr());
|
|
}
|
|
|
|
Network network = ApiDBUtils.findNetworkById(fwRule.getNetworkId());
|
|
response.setNetworkId(network.getUuid());
|
|
|
|
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());
|
|
response.setForDisplay(fwRule.isDisplay());
|
|
|
|
// set tag information
|
|
List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(ResourceObjectType.FirewallRule, fwRule.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses, tagResponse);
|
|
}
|
|
response.setTags(tagResponses);
|
|
|
|
response.setState(stateToSet);
|
|
response.setObjectName("firewallrule");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public NetworkACLItemResponse createNetworkACLItemResponse(NetworkACLItem aclItem) {
|
|
NetworkACLItemResponse response = new NetworkACLItemResponse();
|
|
|
|
response.setId(aclItem.getUuid());
|
|
response.setProtocol(aclItem.getProtocol());
|
|
if (aclItem.getSourcePortStart() != null) {
|
|
response.setStartPort(Integer.toString(aclItem.getSourcePortStart()));
|
|
}
|
|
|
|
if (aclItem.getSourcePortEnd() != null) {
|
|
response.setEndPort(Integer.toString(aclItem.getSourcePortEnd()));
|
|
}
|
|
|
|
response.setCidrList(StringUtils.join(aclItem.getSourceCidrList(), ","));
|
|
|
|
response.setTrafficType(aclItem.getTrafficType().toString());
|
|
|
|
NetworkACLItem.State state = aclItem.getState();
|
|
String stateToSet = state.toString();
|
|
if (state.equals(NetworkACLItem.State.Revoke)) {
|
|
stateToSet = "Deleting";
|
|
}
|
|
|
|
response.setIcmpCode(aclItem.getIcmpCode());
|
|
response.setIcmpType(aclItem.getIcmpType());
|
|
|
|
response.setState(stateToSet);
|
|
response.setNumber(aclItem.getNumber());
|
|
response.setAction(aclItem.getAction().toString());
|
|
response.setForDisplay(aclItem.isDisplay());
|
|
|
|
NetworkACL acl = ApiDBUtils.findByNetworkACLId(aclItem.getAclId());
|
|
if (acl != null) {
|
|
response.setAclId(acl.getUuid());
|
|
}
|
|
|
|
//set tag information
|
|
List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(ResourceObjectType.NetworkACL, aclItem.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses, tagResponse);
|
|
}
|
|
response.setTags(tagResponses);
|
|
response.setReason(aclItem.getReason());
|
|
response.setObjectName("networkacl");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public HypervisorCapabilitiesResponse createHypervisorCapabilitiesResponse(HypervisorCapabilities hpvCapabilities) {
|
|
HypervisorCapabilitiesResponse hpvCapabilitiesResponse = new HypervisorCapabilitiesResponse();
|
|
hpvCapabilitiesResponse.setId(hpvCapabilities.getUuid());
|
|
hpvCapabilitiesResponse.setHypervisor(hpvCapabilities.getHypervisorType());
|
|
hpvCapabilitiesResponse.setHypervisorVersion(hpvCapabilities.getHypervisorVersion());
|
|
hpvCapabilitiesResponse.setIsSecurityGroupEnabled(hpvCapabilities.isSecurityGroupEnabled());
|
|
hpvCapabilitiesResponse.setMaxGuestsLimit(hpvCapabilities.getMaxGuestsLimit());
|
|
hpvCapabilitiesResponse.setMaxDataVolumesLimit(hpvCapabilities.getMaxDataVolumesLimit());
|
|
hpvCapabilitiesResponse.setMaxHostsPerCluster(hpvCapabilities.getMaxHostsPerCluster());
|
|
hpvCapabilitiesResponse.setIsStorageMotionSupported(hpvCapabilities.isStorageMotionSupported());
|
|
return hpvCapabilitiesResponse;
|
|
}
|
|
|
|
// TODO: we may need to refactor once ControlledEntityResponse and
|
|
// ControlledEntity id to uuid conversion are all done.
|
|
// currently code is scattered in
|
|
private void populateOwner(ControlledEntityResponse response, ControlledEntity object) {
|
|
Account account = ApiDBUtils.findAccountById(object.getAccountId());
|
|
|
|
if (account.getType() == Account.ACCOUNT_TYPE_PROJECT) {
|
|
// find the project
|
|
Project project = ApiDBUtils.findProjectByProjectAccountId(account.getId());
|
|
response.setProjectId(project.getUuid());
|
|
response.setProjectName(project.getName());
|
|
} else {
|
|
response.setAccountName(account.getAccountName());
|
|
}
|
|
|
|
Domain domain = ApiDBUtils.findDomainById(object.getDomainId());
|
|
response.setDomainId(domain.getUuid());
|
|
response.setDomainName(domain.getName());
|
|
}
|
|
|
|
public static void populateOwner(ControlledViewEntityResponse response, ControlledViewEntity object) {
|
|
|
|
if (object.getAccountType() == Account.ACCOUNT_TYPE_PROJECT) {
|
|
response.setProjectId(object.getProjectUuid());
|
|
response.setProjectName(object.getProjectName());
|
|
} else {
|
|
response.setAccountName(object.getAccountName());
|
|
}
|
|
|
|
response.setDomainId(object.getDomainUuid());
|
|
response.setDomainName(object.getDomainName());
|
|
}
|
|
|
|
private void populateAccount(ControlledEntityResponse response, long accountId) {
|
|
Account account = ApiDBUtils.findAccountById(accountId);
|
|
if (account == null) {
|
|
s_logger.debug("Unable to find account with id: " + accountId);
|
|
} else if (account.getType() == Account.ACCOUNT_TYPE_PROJECT) {
|
|
// find the project
|
|
Project project = ApiDBUtils.findProjectByProjectAccountId(account.getId());
|
|
if (project != null) {
|
|
response.setProjectId(project.getUuid());
|
|
response.setProjectName(project.getName());
|
|
response.setAccountName(account.getAccountName());
|
|
} else {
|
|
s_logger.debug("Unable to find project with id: " + account.getId());
|
|
}
|
|
} else {
|
|
response.setAccountName(account.getAccountName());
|
|
}
|
|
}
|
|
|
|
private void populateDomain(ControlledEntityResponse response, long domainId) {
|
|
Domain domain = ApiDBUtils.findDomainById(domainId);
|
|
|
|
response.setDomainId(domain.getUuid());
|
|
response.setDomainName(domain.getName());
|
|
}
|
|
|
|
@Override
|
|
public ProjectAccountResponse createProjectAccountResponse(ProjectAccount projectAccount) {
|
|
ProjectAccountJoinVO vProj = ApiDBUtils.newProjectAccountView(projectAccount);
|
|
List<ProjectAccountResponse> listProjs = ViewResponseHelper.createProjectAccountResponse(vProj);
|
|
assert listProjs != null && listProjs.size() == 1 : "There should be one project account returned";
|
|
return listProjs.get(0);
|
|
}
|
|
|
|
@Override
|
|
public ProjectInvitationResponse createProjectInvitationResponse(ProjectInvitation invite) {
|
|
ProjectInvitationJoinVO vInvite = ApiDBUtils.newProjectInvitationView(invite);
|
|
return ApiDBUtils.newProjectInvitationResponse(vInvite);
|
|
}
|
|
|
|
@Override
|
|
public SystemVmInstanceResponse createSystemVmInstanceResponse(VirtualMachine vm) {
|
|
SystemVmInstanceResponse vmResponse = new SystemVmInstanceResponse();
|
|
vmResponse.setId(vm.getUuid());
|
|
vmResponse.setSystemVmType(vm.getType().toString().toLowerCase());
|
|
vmResponse.setName(vm.getHostName());
|
|
if (vm.getHostId() != null) {
|
|
Host host = ApiDBUtils.findHostById(vm.getHostId());
|
|
if (host != null) {
|
|
vmResponse.setHostId(host.getUuid());
|
|
}
|
|
}
|
|
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();
|
|
|
|
DataCenter zone = ApiDBUtils.findZoneById(result.getDataCenterId());
|
|
if (zone != null) {
|
|
response.setZoneId(zone.getUuid());
|
|
}
|
|
response.setNetworkSpeed(result.getSpeed());
|
|
response.setVlan(result.getVnetString());
|
|
if (result.getDomainId() != null) {
|
|
Domain domain = ApiDBUtils.findDomainById(result.getDomainId());
|
|
if (domain != null) {
|
|
response.setDomainId(domain.getUuid());
|
|
}
|
|
}
|
|
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 GuestVlanRangeResponse createDedicatedGuestVlanRangeResponse(GuestVlan vlan) {
|
|
GuestVlanRangeResponse guestVlanRangeResponse = new GuestVlanRangeResponse();
|
|
|
|
guestVlanRangeResponse.setId(vlan.getUuid());
|
|
Long accountId = ApiDBUtils.getAccountIdForGuestVlan(vlan.getId());
|
|
Account owner = ApiDBUtils.findAccountById(accountId);
|
|
if (owner != null) {
|
|
populateAccount(guestVlanRangeResponse, owner.getId());
|
|
populateDomain(guestVlanRangeResponse, owner.getDomainId());
|
|
}
|
|
guestVlanRangeResponse.setGuestVlanRange(vlan.getGuestVlanRange());
|
|
guestVlanRangeResponse.setPhysicalNetworkId(vlan.getPhysicalNetworkId());
|
|
PhysicalNetworkVO physicalNetwork = ApiDBUtils.findPhysicalNetworkById(vlan.getPhysicalNetworkId());
|
|
guestVlanRangeResponse.setZoneId(physicalNetwork.getDataCenterId());
|
|
|
|
return guestVlanRangeResponse;
|
|
}
|
|
|
|
@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/CiscoVnmc as a provider for the firewall
|
|
if (service == Service.Firewall
|
|
&& !(serviceProvider == Provider.VirtualRouter || serviceProvider == Provider.JuniperSRX || serviceProvider == Provider.CiscoVnmc || serviceProvider == Provider.PaloAlto || serviceProvider == Provider.NuageVsp || serviceProvider == Provider.BigSwitchBcf)) {
|
|
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());
|
|
PhysicalNetwork pnw = ApiDBUtils.findPhysicalNetworkById(result.getPhysicalNetworkId());
|
|
if (pnw != null) {
|
|
response.setPhysicalNetworkId(pnw.getUuid());
|
|
}
|
|
PhysicalNetwork dnw = ApiDBUtils.findPhysicalNetworkById(result.getDestinationPhysicalNetworkId());
|
|
if (dnw != null) {
|
|
response.setDestinationPhysicalNetworkId(dnw.getUuid());
|
|
}
|
|
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);
|
|
|
|
Provider serviceProvider = Provider.getProvider(result.getProviderName());
|
|
boolean canEnableIndividualServices = ApiDBUtils.canElementEnableIndividualServices(serviceProvider);
|
|
response.setCanEnableIndividualServices(canEnableIndividualServices);
|
|
|
|
response.setObjectName("networkserviceprovider");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public TrafficTypeResponse createTrafficTypeResponse(PhysicalNetworkTrafficType result) {
|
|
TrafficTypeResponse response = new TrafficTypeResponse();
|
|
response.setId(result.getUuid());
|
|
PhysicalNetwork pnet = ApiDBUtils.findPhysicalNetworkById(result.getPhysicalNetworkId());
|
|
if (pnet != null) {
|
|
response.setPhysicalNetworkId(pnet.getUuid());
|
|
}
|
|
if (result.getTrafficType() != null) {
|
|
response.setTrafficType(result.getTrafficType().toString());
|
|
}
|
|
|
|
response.setXenLabel(result.getXenNetworkLabel());
|
|
response.setKvmLabel(result.getKvmNetworkLabel());
|
|
response.setVmwareLabel(result.getVmwareNetworkLabel());
|
|
response.setHypervLabel(result.getHypervNetworkLabel());
|
|
response.setOvm3Label(result.getOvm3NetworkLabel());
|
|
|
|
response.setObjectName("traffictype");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public VirtualRouterProviderResponse createVirtualRouterProviderResponse(VirtualRouterProvider result) {
|
|
//generate only response of the VR/VPCVR provider type
|
|
if (!(result.getType() == VirtualRouterProvider.Type.VirtualRouter || result.getType() == VirtualRouterProvider.Type.VPCVirtualRouter)) {
|
|
return null;
|
|
}
|
|
VirtualRouterProviderResponse response = new VirtualRouterProviderResponse();
|
|
response.setId(result.getUuid());
|
|
PhysicalNetworkServiceProvider nsp = ApiDBUtils.findPhysicalNetworkServiceProviderById(result.getNspId());
|
|
if (nsp != null) {
|
|
response.setNspId(nsp.getUuid());
|
|
}
|
|
response.setEnabled(result.isEnabled());
|
|
|
|
response.setObjectName("virtualrouterelement");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public OvsProviderResponse createOvsProviderResponse(OvsProvider result) {
|
|
|
|
OvsProviderResponse response = new OvsProviderResponse();
|
|
response.setId(result.getUuid());
|
|
PhysicalNetworkServiceProvider nsp = ApiDBUtils.findPhysicalNetworkServiceProviderById(result.getNspId());
|
|
if (nsp != null) {
|
|
response.setNspId(nsp.getUuid());
|
|
}
|
|
response.setEnabled(result.isEnabled());
|
|
|
|
response.setObjectName("ovselement");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public LBStickinessResponse createLBStickinessPolicyResponse(StickinessPolicy stickinessPolicy, LoadBalancer lb) {
|
|
LBStickinessResponse spResponse = new LBStickinessResponse();
|
|
|
|
spResponse.setlbRuleId(lb.getUuid());
|
|
Account accountTemp = ApiDBUtils.findAccountById(lb.getAccountId());
|
|
if (accountTemp != null) {
|
|
spResponse.setAccountName(accountTemp.getAccountName());
|
|
Domain domain = ApiDBUtils.findDomainById(accountTemp.getDomainId());
|
|
if (domain != null) {
|
|
spResponse.setDomainId(domain.getUuid());
|
|
spResponse.setDomainName(domain.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.getUuid());
|
|
Account account = ApiDBUtils.findAccountById(lb.getAccountId());
|
|
if (account != null) {
|
|
spResponse.setAccountName(account.getAccountName());
|
|
Domain domain = ApiDBUtils.findDomainById(account.getDomainId());
|
|
if (domain != null) {
|
|
spResponse.setDomainId(domain.getUuid());
|
|
spResponse.setDomainName(domain.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 LBHealthCheckResponse createLBHealthCheckPolicyResponse(List<? extends HealthCheckPolicy> healthcheckPolicies, LoadBalancer lb) {
|
|
LBHealthCheckResponse hcResponse = new LBHealthCheckResponse();
|
|
|
|
if (lb == null) {
|
|
return hcResponse;
|
|
}
|
|
hcResponse.setlbRuleId(lb.getUuid());
|
|
Account account = ApiDBUtils.findAccountById(lb.getAccountId());
|
|
if (account != null) {
|
|
hcResponse.setAccountName(account.getAccountName());
|
|
Domain domain = ApiDBUtils.findDomainById(account.getDomainId());
|
|
if (domain != null) {
|
|
hcResponse.setDomainId(domain.getUuid());
|
|
hcResponse.setDomainName(domain.getName());
|
|
}
|
|
}
|
|
|
|
List<LBHealthCheckPolicyResponse> responses = new ArrayList<LBHealthCheckPolicyResponse>();
|
|
for (HealthCheckPolicy healthcheckPolicy : healthcheckPolicies) {
|
|
LBHealthCheckPolicyResponse ruleResponse = new LBHealthCheckPolicyResponse(healthcheckPolicy);
|
|
responses.add(ruleResponse);
|
|
}
|
|
hcResponse.setRules(responses);
|
|
|
|
hcResponse.setObjectName("healthcheckpolicies");
|
|
return hcResponse;
|
|
}
|
|
|
|
@Override
|
|
public LBHealthCheckResponse createLBHealthCheckPolicyResponse(HealthCheckPolicy healthcheckPolicy, LoadBalancer lb) {
|
|
LBHealthCheckResponse hcResponse = new LBHealthCheckResponse();
|
|
|
|
hcResponse.setlbRuleId(lb.getUuid());
|
|
Account accountTemp = ApiDBUtils.findAccountById(lb.getAccountId());
|
|
if (accountTemp != null) {
|
|
hcResponse.setAccountName(accountTemp.getAccountName());
|
|
Domain domain = ApiDBUtils.findDomainById(accountTemp.getDomainId());
|
|
if (domain != null) {
|
|
hcResponse.setDomainId(domain.getUuid());
|
|
hcResponse.setDomainName(domain.getName());
|
|
}
|
|
}
|
|
|
|
List<LBHealthCheckPolicyResponse> responses = new ArrayList<LBHealthCheckPolicyResponse>();
|
|
LBHealthCheckPolicyResponse ruleResponse = new LBHealthCheckPolicyResponse(healthcheckPolicy);
|
|
responses.add(ruleResponse);
|
|
hcResponse.setRules(responses);
|
|
hcResponse.setObjectName("healthcheckpolicies");
|
|
return hcResponse;
|
|
}
|
|
|
|
@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 RegionResponse createRegionResponse(Region region) {
|
|
RegionResponse response = new RegionResponse();
|
|
response.setId(region.getId());
|
|
response.setName(region.getName());
|
|
response.setEndPoint(region.getEndPoint());
|
|
response.setObjectName("region");
|
|
response.setGslbServiceEnabled(region.checkIfServiceEnabled(Region.Service.Gslb));
|
|
response.setPortableipServiceEnabled(region.checkIfServiceEnabled(Region.Service.PortableIp));
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public ResourceTagResponse createResourceTagResponse(ResourceTag resourceTag, boolean keyValueOnly) {
|
|
ResourceTagJoinVO rto = ApiDBUtils.newResourceTagView(resourceTag);
|
|
if(rto == null)
|
|
return null;
|
|
return ApiDBUtils.newResourceTagResponse(rto, keyValueOnly);
|
|
}
|
|
|
|
@Override
|
|
public VpcOfferingResponse createVpcOfferingResponse(VpcOffering offering) {
|
|
VpcOfferingResponse response = new VpcOfferingResponse();
|
|
response.setId(offering.getUuid());
|
|
response.setName(offering.getName());
|
|
response.setDisplayText(offering.getDisplayText());
|
|
response.setIsDefault(offering.isDefault());
|
|
response.setState(offering.getState().name());
|
|
response.setSupportsDistributedRouter(offering.supportsDistributedRouter());
|
|
response.setSupportsRegionLevelVpc(offering.offersRegionLevelVPC());
|
|
|
|
Map<Service, Set<Provider>> serviceProviderMap = ApiDBUtils.listVpcOffServices(offering.getId());
|
|
List<ServiceResponse> serviceResponses = new ArrayList<ServiceResponse>();
|
|
for (Map.Entry<Service, Set<Provider>> entry : serviceProviderMap.entrySet()) {
|
|
Service service = entry.getKey();
|
|
Set<Provider> srvc_providers = entry.getValue();
|
|
|
|
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 : srvc_providers) {
|
|
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(ResponseView view, Vpc vpc) {
|
|
VpcResponse response = new VpcResponse();
|
|
response.setId(vpc.getUuid());
|
|
response.setName(vpc.getName());
|
|
response.setDisplayText(vpc.getDisplayText());
|
|
response.setState(vpc.getState().name());
|
|
VpcOffering voff = ApiDBUtils.findVpcOfferingById(vpc.getVpcOfferingId());
|
|
if (voff != null) {
|
|
response.setVpcOfferingId(voff.getUuid());
|
|
}
|
|
response.setCidr(vpc.getCidr());
|
|
response.setRestartRequired(vpc.isRestartRequired());
|
|
response.setNetworkDomain(vpc.getNetworkDomain());
|
|
response.setForDisplay(vpc.isDisplay());
|
|
response.setUsesDistributedRouter(vpc.usesDistributedRouter());
|
|
response.setRedundantRouter(vpc.isRedundant());
|
|
response.setRegionLevelVpc(vpc.isRegionLevelVpc());
|
|
|
|
Map<Service, Set<Provider>> serviceProviderMap = ApiDBUtils.listVpcOffServices(vpc.getVpcOfferingId());
|
|
List<ServiceResponse> serviceResponses = new ArrayList<ServiceResponse>();
|
|
for (Map.Entry<Service,Set<Provider>>entry : serviceProviderMap.entrySet()) {
|
|
Service service = entry.getKey();
|
|
Set<Provider> serviceProviders = entry.getValue();
|
|
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 : serviceProviders) {
|
|
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(view, network);
|
|
networkResponses.add(ntwkRsp);
|
|
}
|
|
|
|
DataCenter zone = ApiDBUtils.findZoneById(vpc.getZoneId());
|
|
if (zone != null) {
|
|
response.setZoneId(zone.getUuid());
|
|
response.setZoneName(zone.getName());
|
|
}
|
|
|
|
response.setNetworks(networkResponses);
|
|
response.setServices(serviceResponses);
|
|
populateOwner(response, vpc);
|
|
|
|
// set tag information
|
|
List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(ResourceObjectType.Vpc, vpc.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses, tagResponse);
|
|
}
|
|
response.setTags(tagResponses);
|
|
response.setObjectName("vpc");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public PrivateGatewayResponse createPrivateGatewayResponse(PrivateGateway result) {
|
|
PrivateGatewayResponse response = new PrivateGatewayResponse();
|
|
response.setId(result.getUuid());
|
|
response.setBroadcastUri(result.getBroadcastUri());
|
|
response.setGateway(result.getGateway());
|
|
response.setNetmask(result.getNetmask());
|
|
if (result.getVpcId() != null) {
|
|
Vpc vpc = ApiDBUtils.findVpcById(result.getVpcId());
|
|
response.setVpcId(vpc.getUuid());
|
|
}
|
|
|
|
DataCenter zone = ApiDBUtils.findZoneById(result.getZoneId());
|
|
if (zone != null) {
|
|
response.setZoneId(zone.getUuid());
|
|
response.setZoneName(zone.getName());
|
|
}
|
|
response.setAddress(result.getIp4Address());
|
|
PhysicalNetwork pnet = ApiDBUtils.findPhysicalNetworkById(result.getPhysicalNetworkId());
|
|
if (pnet != null) {
|
|
response.setPhysicalNetworkId(pnet.getUuid());
|
|
}
|
|
|
|
populateAccount(response, result.getAccountId());
|
|
populateDomain(response, result.getDomainId());
|
|
response.setState(result.getState().toString());
|
|
response.setSourceNat(result.getSourceNat());
|
|
|
|
NetworkACL acl = ApiDBUtils.findByNetworkACLId(result.getNetworkACLId());
|
|
if (acl != null) {
|
|
response.setAclId(acl.getUuid());
|
|
}
|
|
|
|
response.setObjectName("privategateway");
|
|
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public CounterResponse createCounterResponse(Counter counter) {
|
|
CounterResponse response = new CounterResponse();
|
|
response.setId(counter.getUuid());
|
|
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.getUuid());
|
|
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.getUuid());
|
|
if (profile.getZoneId() != null) {
|
|
DataCenter zone = ApiDBUtils.findZoneById(profile.getZoneId());
|
|
if (zone != null) {
|
|
response.setZoneId(zone.getUuid());
|
|
}
|
|
}
|
|
if (profile.getServiceOfferingId() != null) {
|
|
ServiceOffering so = ApiDBUtils.findServiceOfferingById(profile.getServiceOfferingId());
|
|
if (so != null) {
|
|
response.setServiceOfferingId(so.getUuid());
|
|
}
|
|
}
|
|
if (profile.getTemplateId() != null) {
|
|
VMTemplateVO template = ApiDBUtils.findTemplateById(profile.getTemplateId());
|
|
if (template != null) {
|
|
response.setTemplateId(template.getUuid());
|
|
}
|
|
}
|
|
response.setOtherDeployParams(profile.getOtherDeployParams());
|
|
response.setCounterParams(profile.getCounterParams());
|
|
response.setDestroyVmGraceperiod(profile.getDestroyVmGraceperiod());
|
|
User user = ApiDBUtils.findUserById(profile.getAutoScaleUserId());
|
|
if (user != null) {
|
|
response.setAutoscaleUserId(user.getUuid());
|
|
}
|
|
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.getUuid());
|
|
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.getUuid());
|
|
response.setMinMembers(vmGroup.getMinMembers());
|
|
response.setMaxMembers(vmGroup.getMaxMembers());
|
|
response.setState(vmGroup.getState());
|
|
response.setInterval(vmGroup.getInterval());
|
|
response.setForDisplay(vmGroup.isDisplay());
|
|
AutoScaleVmProfileVO profile = ApiDBUtils.findAutoScaleVmProfileById(vmGroup.getProfileId());
|
|
if (profile != null) {
|
|
response.setProfileId(profile.getUuid());
|
|
}
|
|
FirewallRuleVO fw = ApiDBUtils.findFirewallRuleById(vmGroup.getLoadBalancerId());
|
|
if (fw != null) {
|
|
response.setLoadBalancerId(fw.getUuid());
|
|
}
|
|
|
|
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.getUuid());
|
|
if (result.getVpcId() != null) {
|
|
Vpc vpc = ApiDBUtils.findVpcById(result.getVpcId());
|
|
if (vpc != null) {
|
|
response.setVpcId(vpc.getUuid());
|
|
}
|
|
}
|
|
response.setCidr(result.getCidr());
|
|
|
|
StaticRoute.State state = result.getState();
|
|
if (state.equals(StaticRoute.State.Revoke)) {
|
|
state = StaticRoute.State.Deleting;
|
|
}
|
|
response.setState(state.toString());
|
|
populateAccount(response, result.getAccountId());
|
|
populateDomain(response, result.getDomainId());
|
|
|
|
// set tag information
|
|
List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(ResourceObjectType.StaticRoute, result.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses,tagResponse);
|
|
}
|
|
response.setTags(tagResponses);
|
|
response.setObjectName("staticroute");
|
|
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public Site2SiteVpnGatewayResponse createSite2SiteVpnGatewayResponse(Site2SiteVpnGateway result) {
|
|
Site2SiteVpnGatewayResponse response = new Site2SiteVpnGatewayResponse();
|
|
response.setId(result.getUuid());
|
|
response.setIp(ApiDBUtils.findIpAddressById(result.getAddrId()).getAddress().toString());
|
|
Vpc vpc = ApiDBUtils.findVpcById(result.getVpcId());
|
|
if (vpc != null) {
|
|
response.setVpcId(vpc.getUuid());
|
|
}
|
|
response.setRemoved(result.getRemoved());
|
|
response.setForDisplay(result.isDisplay());
|
|
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.getUuid());
|
|
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.setEncap(result.getEncap());
|
|
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.getUuid());
|
|
response.setPassive(result.isPassive());
|
|
|
|
Long vpnGatewayId = result.getVpnGatewayId();
|
|
if (vpnGatewayId != null) {
|
|
Site2SiteVpnGateway vpnGateway = ApiDBUtils.findVpnGatewayById(vpnGatewayId);
|
|
if (vpnGateway != null) {
|
|
response.setVpnGatewayId(vpnGateway.getUuid());
|
|
long ipId = vpnGateway.getAddrId();
|
|
IPAddressVO ipObj = ApiDBUtils.findIpAddressById(ipId);
|
|
response.setIp(ipObj.getAddress().addr());
|
|
}
|
|
}
|
|
|
|
Long customerGatewayId = result.getCustomerGatewayId();
|
|
if (customerGatewayId != null) {
|
|
Site2SiteCustomerGateway customerGateway = ApiDBUtils.findCustomerGatewayById(customerGatewayId);
|
|
if (customerGateway != null) {
|
|
response.setCustomerGatewayId(customerGateway.getUuid());
|
|
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());
|
|
response.setEncap(customerGateway.getEncap());
|
|
}
|
|
}
|
|
|
|
populateAccount(response, result.getAccountId());
|
|
populateDomain(response, result.getDomainId());
|
|
|
|
response.setState(result.getState().toString());
|
|
response.setCreated(result.getCreated());
|
|
response.setRemoved(result.getRemoved());
|
|
response.setForDisplay(result.isDisplay());
|
|
response.setObjectName("vpnconnection");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public GuestOSResponse createGuestOSResponse(GuestOS guestOS) {
|
|
GuestOSResponse response = new GuestOSResponse();
|
|
response.setDescription(guestOS.getDisplayName());
|
|
response.setId(guestOS.getUuid());
|
|
response.setIsUserDefined(Boolean.valueOf(guestOS.getIsUserDefined()).toString());
|
|
GuestOSCategoryVO category = ApiDBUtils.findGuestOsCategoryById(guestOS.getCategoryId());
|
|
if (category != null) {
|
|
response.setOsCategoryId(category.getUuid());
|
|
}
|
|
|
|
response.setObjectName("ostype");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public GuestOsMappingResponse createGuestOSMappingResponse(GuestOSHypervisor guestOSHypervisor) {
|
|
GuestOsMappingResponse response = new GuestOsMappingResponse();
|
|
response.setId(guestOSHypervisor.getUuid());
|
|
response.setHypervisor(guestOSHypervisor.getHypervisorType());
|
|
response.setHypervisorVersion(guestOSHypervisor.getHypervisorVersion());
|
|
response.setOsNameForHypervisor((guestOSHypervisor.getGuestOsName()));
|
|
response.setIsUserDefined(Boolean.valueOf(guestOSHypervisor.getIsUserDefined()).toString());
|
|
GuestOS guestOs = ApiDBUtils.findGuestOSById(guestOSHypervisor.getGuestOsId());
|
|
if (guestOs != null) {
|
|
response.setOsStdName(guestOs.getDisplayName());
|
|
response.setOsTypeId(guestOs.getUuid());
|
|
}
|
|
|
|
response.setObjectName("guestosmapping");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public SnapshotScheduleResponse createSnapshotScheduleResponse(SnapshotSchedule snapshotSchedule) {
|
|
SnapshotScheduleResponse response = new SnapshotScheduleResponse();
|
|
response.setId(snapshotSchedule.getUuid());
|
|
if (snapshotSchedule.getVolumeId() != null) {
|
|
Volume vol = ApiDBUtils.findVolumeById(snapshotSchedule.getVolumeId());
|
|
if (vol != null) {
|
|
response.setVolumeId(vol.getUuid());
|
|
}
|
|
}
|
|
if (snapshotSchedule.getPolicyId() != null) {
|
|
SnapshotPolicy policy = ApiDBUtils.findSnapshotPolicyById(snapshotSchedule.getPolicyId());
|
|
if (policy != null) {
|
|
response.setSnapshotPolicyId(policy.getUuid());
|
|
}
|
|
}
|
|
response.setScheduled(snapshotSchedule.getScheduledTimestamp());
|
|
|
|
response.setObjectName("snapshot");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public Map<String, Set<ResourceTagResponse>> getUsageResourceTags()
|
|
{
|
|
try {
|
|
return _resourceTagDao.listTags();
|
|
} catch(Exception ex) {
|
|
s_logger.warn("Failed to get resource details for Usage data due to exception : ", ex);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public UsageRecordResponse createUsageResponse(Usage usageRecord) {
|
|
return createUsageResponse(usageRecord, null);
|
|
}
|
|
|
|
@Override
|
|
public UsageRecordResponse createUsageResponse(Usage usageRecord, Map<String, Set<ResourceTagResponse>> resourceTagResponseMap) {
|
|
UsageRecordResponse usageRecResponse = new UsageRecordResponse();
|
|
Account account = ApiDBUtils.findAccountById(usageRecord.getAccountId());
|
|
if (account.getType() == Account.ACCOUNT_TYPE_PROJECT) {
|
|
//find the project
|
|
Project project = ApiDBUtils.findProjectByProjectAccountIdIncludingRemoved(account.getId());
|
|
if (project != null) {
|
|
usageRecResponse.setProjectId(project.getUuid());
|
|
usageRecResponse.setProjectName(project.getName());
|
|
}
|
|
} else {
|
|
usageRecResponse.setAccountId(account.getUuid());
|
|
usageRecResponse.setAccountName(account.getAccountName());
|
|
}
|
|
|
|
Domain domain = ApiDBUtils.findDomainById(usageRecord.getDomainId());
|
|
if (domain != null) {
|
|
usageRecResponse.setDomainId(domain.getUuid());
|
|
usageRecResponse.setDomainName(domain.getName());
|
|
}
|
|
|
|
if (usageRecord.getZoneId() != null) {
|
|
DataCenter zone = ApiDBUtils.findZoneById(usageRecord.getZoneId());
|
|
if (zone != null) {
|
|
usageRecResponse.setZoneId(zone.getUuid());
|
|
}
|
|
}
|
|
usageRecResponse.setDescription(usageRecord.getDescription());
|
|
usageRecResponse.setUsage(usageRecord.getUsageDisplay());
|
|
usageRecResponse.setUsageType(usageRecord.getUsageType());
|
|
if (usageRecord.getVmInstanceId() != null) {
|
|
VMInstanceVO vm = _entityMgr.findByIdIncludingRemoved(VMInstanceVO.class, usageRecord.getVmInstanceId());
|
|
if (vm != null) {
|
|
usageRecResponse.setVirtualMachineId(vm.getUuid());
|
|
}
|
|
}
|
|
usageRecResponse.setVmName(usageRecord.getVmName());
|
|
if (usageRecord.getTemplateId() != null) {
|
|
VMTemplateVO template = ApiDBUtils.findTemplateById(usageRecord.getTemplateId());
|
|
if (template != null) {
|
|
usageRecResponse.setTemplateId(template.getUuid());
|
|
}
|
|
}
|
|
|
|
ResourceTag.ResourceObjectType resourceType = null;
|
|
Long resourceId = null;
|
|
if (usageRecord.getUsageType() == UsageTypes.RUNNING_VM || usageRecord.getUsageType() == UsageTypes.ALLOCATED_VM) {
|
|
ServiceOfferingVO svcOffering = _entityMgr.findByIdIncludingRemoved(ServiceOfferingVO.class, usageRecord.getOfferingId().toString());
|
|
//Service Offering Id
|
|
if(svcOffering != null) {
|
|
usageRecResponse.setOfferingId(svcOffering.getUuid());
|
|
}
|
|
//VM Instance ID
|
|
VMInstanceVO vm = _entityMgr.findByIdIncludingRemoved(VMInstanceVO.class, usageRecord.getUsageId().toString());
|
|
if (vm != null) {
|
|
resourceType = ResourceTag.ResourceObjectType.UserVm;
|
|
usageRecResponse.setUsageId(vm.getUuid());
|
|
resourceId = vm.getId();
|
|
}
|
|
//Hypervisor Type
|
|
usageRecResponse.setType(usageRecord.getType());
|
|
//Dynamic compute offerings details
|
|
if(usageRecord.getCpuCores() != null) {
|
|
usageRecResponse.setCpuNumber(usageRecord.getCpuCores());
|
|
} else if (svcOffering.getCpu() != null){
|
|
usageRecResponse.setCpuNumber(svcOffering.getCpu().longValue());
|
|
}
|
|
if(usageRecord.getCpuSpeed() != null) {
|
|
usageRecResponse.setCpuSpeed(usageRecord.getCpuSpeed());
|
|
} else if(svcOffering.getSpeed() != null){
|
|
usageRecResponse.setCpuSpeed(svcOffering.getSpeed().longValue());
|
|
}
|
|
if(usageRecord.getMemory() != null) {
|
|
usageRecResponse.setMemory(usageRecord.getMemory());
|
|
} else if(svcOffering.getRamSize() != null) {
|
|
usageRecResponse.setMemory(svcOffering.getRamSize().longValue());
|
|
}
|
|
|
|
} else if (usageRecord.getUsageType() == UsageTypes.IP_ADDRESS) {
|
|
//isSourceNAT
|
|
usageRecResponse.setSourceNat((usageRecord.getType().equals("SourceNat")) ? true : false);
|
|
//isSystem
|
|
usageRecResponse.setSystem((usageRecord.getSize() == 1) ? true : false);
|
|
//IP Address ID
|
|
IPAddressVO ip = _entityMgr.findByIdIncludingRemoved(IPAddressVO.class, usageRecord.getUsageId().toString());
|
|
if (ip != null) {
|
|
resourceType = ResourceObjectType.PublicIpAddress;
|
|
resourceId = ip.getId();
|
|
usageRecResponse.setUsageId(ip.getUuid());
|
|
}
|
|
|
|
} else if (usageRecord.getUsageType() == UsageTypes.NETWORK_BYTES_SENT || usageRecord.getUsageType() == UsageTypes.NETWORK_BYTES_RECEIVED) {
|
|
//Device Type
|
|
resourceType = ResourceObjectType.UserVm;
|
|
usageRecResponse.setType(usageRecord.getType());
|
|
if (usageRecord.getType().equals("DomainRouter") || usageRecord.getType().equals("UserVm")) {
|
|
//Domain Router Id
|
|
VMInstanceVO vm = _entityMgr.findByIdIncludingRemoved(VMInstanceVO.class, usageRecord.getUsageId().toString());
|
|
if (vm != null) {
|
|
resourceId = vm.getId();
|
|
usageRecResponse.setUsageId(vm.getUuid());
|
|
}
|
|
} else {
|
|
//External Device Host Id
|
|
HostVO host = _entityMgr.findByIdIncludingRemoved(HostVO.class, usageRecord.getUsageId().toString());
|
|
if (host != null) {
|
|
usageRecResponse.setUsageId(host.getUuid());
|
|
}
|
|
}
|
|
//Network ID
|
|
if((usageRecord.getNetworkId() != null) && (usageRecord.getNetworkId() != 0)) {
|
|
NetworkVO network = _entityMgr.findByIdIncludingRemoved(NetworkVO.class, usageRecord.getNetworkId().toString());
|
|
if (network != null) {
|
|
resourceType = ResourceObjectType.Network;
|
|
resourceId = network.getId();
|
|
usageRecResponse.setNetworkId(network.getUuid());
|
|
}
|
|
}
|
|
} else if (usageRecord.getUsageType() == UsageTypes.VM_DISK_IO_READ || usageRecord.getUsageType() == UsageTypes.VM_DISK_IO_WRITE
|
|
|| usageRecord.getUsageType() == UsageTypes.VM_DISK_BYTES_READ || usageRecord.getUsageType() == UsageTypes.VM_DISK_BYTES_WRITE) {
|
|
//Device Type
|
|
usageRecResponse.setType(usageRecord.getType());
|
|
resourceType = ResourceObjectType.Volume;
|
|
//VM Instance Id
|
|
VMInstanceVO vm = _entityMgr.findByIdIncludingRemoved(VMInstanceVO.class, usageRecord.getVmInstanceId().toString());
|
|
if (vm != null) {
|
|
usageRecResponse.setVirtualMachineId(vm.getUuid());
|
|
}
|
|
//Volume ID
|
|
VolumeVO volume = _entityMgr.findByIdIncludingRemoved(VolumeVO.class, usageRecord.getUsageId().toString());
|
|
if (volume != null) {
|
|
usageRecResponse.setUsageId(volume.getUuid());
|
|
resourceId = volume.getId();
|
|
}
|
|
|
|
} else if (usageRecord.getUsageType() == UsageTypes.VOLUME) {
|
|
//Volume ID
|
|
VolumeVO volume = _entityMgr.findByIdIncludingRemoved(VolumeVO.class, usageRecord.getUsageId().toString());
|
|
resourceType = ResourceObjectType.Volume;
|
|
if (volume != null) {
|
|
usageRecResponse.setUsageId(volume.getUuid());
|
|
resourceId = volume.getId();
|
|
}
|
|
//Volume Size
|
|
usageRecResponse.setSize(usageRecord.getSize());
|
|
//Disk Offering Id
|
|
if (usageRecord.getOfferingId() != null) {
|
|
DiskOfferingVO diskOff = _entityMgr.findByIdIncludingRemoved(DiskOfferingVO.class, usageRecord.getOfferingId().toString());
|
|
usageRecResponse.setOfferingId(diskOff.getUuid());
|
|
}
|
|
|
|
} else if (usageRecord.getUsageType() == UsageTypes.TEMPLATE || usageRecord.getUsageType() == UsageTypes.ISO) {
|
|
//Template/ISO ID
|
|
VMTemplateVO tmpl = _entityMgr.findByIdIncludingRemoved(VMTemplateVO.class, usageRecord.getUsageId().toString());
|
|
if (tmpl != null) {
|
|
usageRecResponse.setUsageId(tmpl.getUuid());
|
|
resourceId = tmpl.getId();
|
|
}
|
|
//Template/ISO Size
|
|
usageRecResponse.setSize(usageRecord.getSize());
|
|
if (usageRecord.getUsageType() == UsageTypes.ISO) {
|
|
usageRecResponse.setVirtualSize(usageRecord.getSize());
|
|
resourceType = ResourceObjectType.ISO;
|
|
} else {
|
|
usageRecResponse.setVirtualSize(usageRecord.getVirtualSize());
|
|
resourceType = ResourceObjectType.Template;
|
|
}
|
|
|
|
} else if (usageRecord.getUsageType() == UsageTypes.SNAPSHOT) {
|
|
//Snapshot ID
|
|
SnapshotVO snap = _entityMgr.findByIdIncludingRemoved(SnapshotVO.class, usageRecord.getUsageId().toString());
|
|
resourceType = ResourceObjectType.Snapshot;
|
|
if (snap != null) {
|
|
usageRecResponse.setUsageId(snap.getUuid());
|
|
resourceId = snap.getId();
|
|
}
|
|
//Snapshot Size
|
|
usageRecResponse.setSize(usageRecord.getSize());
|
|
|
|
} else if (usageRecord.getUsageType() == UsageTypes.LOAD_BALANCER_POLICY) {
|
|
//Load Balancer Policy ID
|
|
LoadBalancerVO lb = _entityMgr.findByIdIncludingRemoved(LoadBalancerVO.class, usageRecord.getUsageId().toString());
|
|
resourceType = ResourceObjectType.LoadBalancer;
|
|
if (lb != null) {
|
|
usageRecResponse.setUsageId(lb.getUuid());
|
|
resourceId = lb.getId();
|
|
}
|
|
} else if (usageRecord.getUsageType() == UsageTypes.PORT_FORWARDING_RULE) {
|
|
//Port Forwarding Rule ID
|
|
PortForwardingRuleVO pf = _entityMgr.findByIdIncludingRemoved(PortForwardingRuleVO.class, usageRecord.getUsageId().toString());
|
|
resourceType = ResourceObjectType.PortForwardingRule;
|
|
if (pf != null) {
|
|
usageRecResponse.setUsageId(pf.getUuid());
|
|
resourceId = pf.getId();
|
|
}
|
|
|
|
} else if (usageRecord.getUsageType() == UsageTypes.NETWORK_OFFERING) {
|
|
//Network Offering Id
|
|
NetworkOfferingVO netOff = _entityMgr.findByIdIncludingRemoved(NetworkOfferingVO.class, usageRecord.getOfferingId().toString());
|
|
usageRecResponse.setOfferingId(netOff.getUuid());
|
|
//is Default
|
|
usageRecResponse.setDefault((usageRecord.getUsageId() == 1) ? true : false);
|
|
|
|
} else if (usageRecord.getUsageType() == UsageTypes.VPN_USERS) {
|
|
//VPN User ID
|
|
VpnUserVO vpnUser = _entityMgr.findByIdIncludingRemoved(VpnUserVO.class, usageRecord.getUsageId().toString());
|
|
if (vpnUser != null) {
|
|
usageRecResponse.setUsageId(vpnUser.getUuid());
|
|
}
|
|
} else if (usageRecord.getUsageType() == UsageTypes.SECURITY_GROUP) {
|
|
//Security Group Id
|
|
SecurityGroupVO sg = _entityMgr.findByIdIncludingRemoved(SecurityGroupVO.class, usageRecord.getUsageId().toString());
|
|
resourceType = ResourceObjectType.SecurityGroup;
|
|
if (sg != null) {
|
|
resourceId = sg.getId();
|
|
usageRecResponse.setUsageId(sg.getUuid());
|
|
}
|
|
} else if (usageRecord.getUsageType() == UsageTypes.VM_SNAPSHOT) {
|
|
VMInstanceVO vm = _entityMgr.findByIdIncludingRemoved(VMInstanceVO.class, usageRecord.getVmInstanceId().toString());
|
|
resourceType = ResourceObjectType.UserVm;
|
|
if (vm != null) {
|
|
resourceId = vm.getId();
|
|
usageRecResponse.setVmName(vm.getInstanceName());
|
|
usageRecResponse.setUsageId(vm.getUuid());
|
|
}
|
|
usageRecResponse.setSize(usageRecord.getSize());
|
|
if (usageRecord.getOfferingId() != null) {
|
|
usageRecResponse.setOfferingId(usageRecord.getOfferingId().toString());
|
|
}
|
|
}
|
|
|
|
if(resourceTagResponseMap != null && resourceTagResponseMap.get(resourceId + ":" + resourceType) != null) {
|
|
usageRecResponse.setTags(resourceTagResponseMap.get(resourceId + ":" + resourceType));
|
|
}
|
|
|
|
if (usageRecord.getRawUsage() != null) {
|
|
DecimalFormat decimalFormat = new DecimalFormat("###########.######");
|
|
usageRecResponse.setRawUsage(decimalFormat.format(usageRecord.getRawUsage()));
|
|
}
|
|
|
|
if (usageRecord.getStartDate() != null) {
|
|
usageRecResponse.setStartDate(getDateStringInternal(usageRecord.getStartDate()));
|
|
}
|
|
if (usageRecord.getEndDate() != null) {
|
|
usageRecResponse.setEndDate(getDateStringInternal(usageRecord.getEndDate()));
|
|
}
|
|
|
|
return usageRecResponse;
|
|
}
|
|
|
|
public String getDateStringInternal(Date inputDate) {
|
|
if (inputDate == null) {
|
|
return null;
|
|
}
|
|
|
|
TimeZone tz = _usageSvc.getUsageTimezone();
|
|
Calendar cal = Calendar.getInstance(tz);
|
|
cal.setTime(inputDate);
|
|
|
|
StringBuilder sb = new StringBuilder(32);
|
|
sb.append(cal.get(Calendar.YEAR)).append('-');
|
|
|
|
int month = cal.get(Calendar.MONTH) + 1;
|
|
if (month < 10) {
|
|
sb.append('0');
|
|
}
|
|
sb.append(month).append('-');
|
|
|
|
int day = cal.get(Calendar.DAY_OF_MONTH);
|
|
if (day < 10) {
|
|
sb.append('0');
|
|
}
|
|
sb.append(day);
|
|
|
|
sb.append("'T'");
|
|
|
|
int hour = cal.get(Calendar.HOUR_OF_DAY);
|
|
if (hour < 10) {
|
|
sb.append('0');
|
|
}
|
|
sb.append(hour).append(':');
|
|
|
|
int minute = cal.get(Calendar.MINUTE);
|
|
if (minute < 10) {
|
|
sb.append('0');
|
|
}
|
|
sb.append(minute).append(':');
|
|
|
|
int seconds = cal.get(Calendar.SECOND);
|
|
if (seconds < 10) {
|
|
sb.append('0');
|
|
}
|
|
sb.append(seconds);
|
|
|
|
double offset = cal.get(Calendar.ZONE_OFFSET);
|
|
if (tz.inDaylightTime(inputDate)) {
|
|
offset += (1.0 * tz.getDSTSavings()); // add the timezone's DST
|
|
// value (typically 1 hour
|
|
// expressed in milliseconds)
|
|
}
|
|
|
|
offset = offset / (1000d * 60d * 60d);
|
|
int hourOffset = (int)offset;
|
|
double decimalVal = Math.abs(offset) - Math.abs(hourOffset);
|
|
int minuteOffset = (int)(decimalVal * 60);
|
|
|
|
if (hourOffset < 0) {
|
|
if (hourOffset > -10) {
|
|
sb.append("-0");
|
|
} else {
|
|
sb.append('-');
|
|
}
|
|
sb.append(Math.abs(hourOffset));
|
|
} else {
|
|
if (hourOffset < 10) {
|
|
sb.append("+0");
|
|
} else {
|
|
sb.append("+");
|
|
}
|
|
sb.append(hourOffset);
|
|
}
|
|
|
|
sb.append(':');
|
|
|
|
if (minuteOffset == 0) {
|
|
sb.append("00");
|
|
} else if (minuteOffset < 10) {
|
|
sb.append('0').append(minuteOffset);
|
|
} else {
|
|
sb.append(minuteOffset);
|
|
}
|
|
|
|
return sb.toString();
|
|
}
|
|
|
|
@Override
|
|
public TrafficMonitorResponse createTrafficMonitorResponse(Host trafficMonitor) {
|
|
Map<String, String> tmDetails = ApiDBUtils.findHostDetailsById(trafficMonitor.getId());
|
|
TrafficMonitorResponse response = new TrafficMonitorResponse();
|
|
response.setId(trafficMonitor.getUuid());
|
|
response.setIpAddress(trafficMonitor.getPrivateIpAddress());
|
|
response.setNumRetries(tmDetails.get("numRetries"));
|
|
response.setTimeout(tmDetails.get("timeout"));
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public NicSecondaryIpResponse createSecondaryIPToNicResponse(NicSecondaryIp result) {
|
|
NicSecondaryIpResponse response = new NicSecondaryIpResponse();
|
|
NicVO nic = _entityMgr.findById(NicVO.class, result.getNicId());
|
|
NetworkVO network = _entityMgr.findById(NetworkVO.class, result.getNetworkId());
|
|
response.setId(result.getUuid());
|
|
response.setIpAddr(result.getIp4Address());
|
|
response.setNicId(nic.getUuid());
|
|
response.setNwId(network.getUuid());
|
|
response.setObjectName("nicsecondaryip");
|
|
return response;
|
|
}
|
|
|
|
/**
|
|
* The resulting Response attempts to be in line with what is returned from
|
|
* @see com.cloud.api.query.dao.UserVmJoinDaoImpl#setUserVmResponse(ResponseView, UserVmResponse, UserVmJoinVO)
|
|
*/
|
|
@Override
|
|
public NicResponse createNicResponse(Nic result) {
|
|
NicResponse response = new NicResponse();
|
|
NetworkVO network = _entityMgr.findById(NetworkVO.class, result.getNetworkId());
|
|
VMInstanceVO vm = _entityMgr.findById(VMInstanceVO.class, result.getInstanceId());
|
|
UserVmJoinVO userVm = _entityMgr.findById(UserVmJoinVO.class, result.getInstanceId());
|
|
List<NicExtraDhcpOptionVO> nicExtraDhcpOptionVOs = _nicExtraDhcpOptionDao.listByNicId(result.getId());
|
|
|
|
// The numbered comments are to keep track of the data returned from here and UserVmJoinDaoImpl.setUserVmResponse()
|
|
// the data can't be identical but some tidying up/unifying might be possible
|
|
/*1: nicUuid*/
|
|
response.setId(result.getUuid());
|
|
/*2: networkUuid*/
|
|
response.setNetworkid(network.getUuid());
|
|
/*3: vmId*/
|
|
if (vm != null) {
|
|
response.setVmId(vm.getUuid());
|
|
}
|
|
|
|
if (userVm != null){
|
|
if (userVm.getTrafficType() != null) {
|
|
/*4: trafficType*/
|
|
response.setTrafficType(userVm.getTrafficType().toString());
|
|
}
|
|
if (userVm.getGuestType() != null) {
|
|
/*5: guestType*/
|
|
response.setType(userVm.getGuestType().toString());
|
|
}
|
|
}
|
|
/*6: ipAddress*/
|
|
response.setIpaddress(result.getIPv4Address());
|
|
/*7: gateway*/
|
|
response.setGateway(result.getIPv4Gateway());
|
|
/*8: netmask*/
|
|
response.setNetmask(result.getIPv4Netmask());
|
|
/*9: networkName*/
|
|
if(userVm != null && userVm.getNetworkName() != null) {
|
|
response.setNetworkName(userVm.getNetworkName());
|
|
}
|
|
/*10: macAddress*/
|
|
response.setMacAddress(result.getMacAddress());
|
|
/*11: IPv6Address*/
|
|
if (result.getIPv6Address() != null) {
|
|
response.setIp6Address(result.getIPv6Address());
|
|
}
|
|
/*12: IPv6Gateway*/
|
|
if (result.getIPv6Gateway() != null) {
|
|
response.setIp6Gateway(result.getIPv6Gateway());
|
|
}
|
|
/*13: IPv6Cidr*/
|
|
if (result.getIPv6Cidr() != null) {
|
|
response.setIp6Cidr(result.getIPv6Cidr());
|
|
}
|
|
/*14: deviceId*/
|
|
response.setDeviceId(String.valueOf(result.getDeviceId()));
|
|
/*15: broadcastURI*/
|
|
if (result.getBroadcastUri() != null) {
|
|
response.setBroadcastUri(result.getBroadcastUri().toString());
|
|
}
|
|
/*16: isolationURI*/
|
|
if (result.getIsolationUri() != null) {
|
|
response.setIsolationUri(result.getIsolationUri().toString());
|
|
}
|
|
/*17: default*/
|
|
response.setIsDefault(result.isDefaultNic());
|
|
if (result.getSecondaryIp()) {
|
|
List<NicSecondaryIpVO> secondaryIps = ApiDBUtils.findNicSecondaryIps(result.getId());
|
|
if (secondaryIps != null) {
|
|
List<NicSecondaryIpResponse> ipList = new ArrayList<NicSecondaryIpResponse>();
|
|
for (NicSecondaryIpVO ip : secondaryIps) {
|
|
NicSecondaryIpResponse ipRes = new NicSecondaryIpResponse();
|
|
ipRes.setId(ip.getUuid());
|
|
ipRes.setIpAddr(ip.getIp4Address());
|
|
ipList.add(ipRes);
|
|
}
|
|
response.setSecondaryIps(ipList);
|
|
}
|
|
}
|
|
/*18: extra dhcp options */
|
|
List<NicExtraDhcpOptionResponse> nicExtraDhcpOptionResponses = nicExtraDhcpOptionVOs
|
|
.stream()
|
|
.map(vo -> new NicExtraDhcpOptionResponse(Dhcp.DhcpOptionCode.valueOfInt(vo.getCode()).getName(), vo.getCode(), vo.getValue()))
|
|
.collect(Collectors.toList());
|
|
|
|
response.setExtraDhcpOptions(nicExtraDhcpOptionResponses);
|
|
|
|
if (result instanceof NicVO){
|
|
if (((NicVO)result).getNsxLogicalSwitchUuid() != null){
|
|
response.setNsxLogicalSwitch(((NicVO)result).getNsxLogicalSwitchUuid());
|
|
}
|
|
if (((NicVO)result).getNsxLogicalSwitchPortUuid() != null){
|
|
response.setNsxLogicalSwitchPort(((NicVO)result).getNsxLogicalSwitchPortUuid());
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public ApplicationLoadBalancerResponse createLoadBalancerContainerReponse(ApplicationLoadBalancerRule lb, Map<Ip, UserVm> lbInstances) {
|
|
|
|
ApplicationLoadBalancerResponse lbResponse = new ApplicationLoadBalancerResponse();
|
|
lbResponse.setId(lb.getUuid());
|
|
lbResponse.setName(lb.getName());
|
|
lbResponse.setDescription(lb.getDescription());
|
|
lbResponse.setAlgorithm(lb.getAlgorithm());
|
|
lbResponse.setForDisplay(lb.isDisplay());
|
|
Network nw = ApiDBUtils.findNetworkById(lb.getNetworkId());
|
|
lbResponse.setNetworkId(nw.getUuid());
|
|
populateOwner(lbResponse, lb);
|
|
|
|
if (lb.getScheme() == Scheme.Internal) {
|
|
lbResponse.setSourceIp(lb.getSourceIp().addr());
|
|
//TODO - create the view for the load balancer rule to reflect the network uuid
|
|
Network network = ApiDBUtils.findNetworkById(lb.getNetworkId());
|
|
lbResponse.setSourceIpNetworkId(network.getUuid());
|
|
} else {
|
|
//for public, populate the ip information from the ip address
|
|
IpAddress publicIp = ApiDBUtils.findIpAddressById(lb.getSourceIpAddressId());
|
|
lbResponse.setSourceIp(publicIp.getAddress().addr());
|
|
Network ntwk = ApiDBUtils.findNetworkById(publicIp.getNetworkId());
|
|
lbResponse.setSourceIpNetworkId(ntwk.getUuid());
|
|
}
|
|
|
|
//set load balancer rules information (only one rule per load balancer in this release)
|
|
List<ApplicationLoadBalancerRuleResponse> ruleResponses = new ArrayList<ApplicationLoadBalancerRuleResponse>();
|
|
ApplicationLoadBalancerRuleResponse ruleResponse = new ApplicationLoadBalancerRuleResponse();
|
|
ruleResponse.setInstancePort(lb.getDefaultPortStart());
|
|
ruleResponse.setSourcePort(lb.getSourcePortStart());
|
|
FirewallRule.State stateToSet = lb.getState();
|
|
if (stateToSet.equals(FirewallRule.State.Revoke)) {
|
|
stateToSet = FirewallRule.State.Deleting;
|
|
}
|
|
ruleResponse.setState(stateToSet.toString());
|
|
ruleResponse.setObjectName("loadbalancerrule");
|
|
ruleResponses.add(ruleResponse);
|
|
lbResponse.setLbRules(ruleResponses);
|
|
|
|
//set Lb instances information
|
|
List<ApplicationLoadBalancerInstanceResponse> instanceResponses = new ArrayList<ApplicationLoadBalancerInstanceResponse>();
|
|
for (Map.Entry<Ip,UserVm> entry : lbInstances.entrySet()) {
|
|
Ip ip = entry.getKey();
|
|
UserVm vm = entry.getValue();
|
|
ApplicationLoadBalancerInstanceResponse instanceResponse = new ApplicationLoadBalancerInstanceResponse();
|
|
instanceResponse.setIpAddress(ip.addr());
|
|
instanceResponse.setId(vm.getUuid());
|
|
instanceResponse.setName(vm.getInstanceName());
|
|
instanceResponse.setObjectName("loadbalancerinstance");
|
|
instanceResponses.add(instanceResponse);
|
|
}
|
|
|
|
lbResponse.setLbInstances(instanceResponses);
|
|
|
|
//set tag information
|
|
List<? extends ResourceTag> tags = ApiDBUtils.listByResourceTypeAndId(ResourceObjectType.LoadBalancer, lb.getId());
|
|
List<ResourceTagResponse> tagResponses = new ArrayList<ResourceTagResponse>();
|
|
for (ResourceTag tag : tags) {
|
|
ResourceTagResponse tagResponse = createResourceTagResponse(tag, true);
|
|
CollectionUtils.addIgnoreNull(tagResponses,tagResponse);
|
|
}
|
|
lbResponse.setTags(tagResponses);
|
|
|
|
lbResponse.setObjectName("loadbalancer");
|
|
return lbResponse;
|
|
}
|
|
|
|
@Override
|
|
public AffinityGroupResponse createAffinityGroupResponse(AffinityGroup group) {
|
|
|
|
AffinityGroupResponse response = new AffinityGroupResponse();
|
|
|
|
Account account = ApiDBUtils.findAccountById(group.getAccountId());
|
|
response.setId(group.getUuid());
|
|
response.setAccountName(account.getAccountName());
|
|
response.setName(group.getName());
|
|
response.setType(group.getType());
|
|
response.setDescription(group.getDescription());
|
|
Domain domain = ApiDBUtils.findDomainById(account.getDomainId());
|
|
if (domain != null) {
|
|
response.setDomainId(domain.getUuid());
|
|
response.setDomainName(domain.getName());
|
|
}
|
|
|
|
response.setObjectName("affinitygroup");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public Long getAffinityGroupId(String groupName, long accountId) {
|
|
AffinityGroup ag = ApiDBUtils.getAffinityGroup(groupName, accountId);
|
|
if (ag == null) {
|
|
return null;
|
|
} else {
|
|
return ag.getId();
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public PortableIpRangeResponse createPortableIPRangeResponse(PortableIpRange ipRange) {
|
|
PortableIpRangeResponse response = new PortableIpRangeResponse();
|
|
response.setId(ipRange.getUuid());
|
|
String ipRangeStr = ipRange.getIpRange();
|
|
if (ipRangeStr != null) {
|
|
String[] range = ipRangeStr.split("-");
|
|
response.setStartIp(range[0]);
|
|
response.setEndIp(range[1]);
|
|
}
|
|
response.setVlan(ipRange.getVlanTag());
|
|
response.setGateway(ipRange.getGateway());
|
|
response.setNetmask(ipRange.getNetmask());
|
|
response.setRegionId(ipRange.getRegionId());
|
|
response.setObjectName("portableiprange");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public PortableIpResponse createPortableIPResponse(PortableIp portableIp) {
|
|
PortableIpResponse response = new PortableIpResponse();
|
|
response.setAddress(portableIp.getAddress());
|
|
Long accountId = portableIp.getAllocatedInDomainId();
|
|
if (accountId != null) {
|
|
Account account = ApiDBUtils.findAccountById(accountId);
|
|
response.setAllocatedToAccountId(account.getAccountName());
|
|
Domain domain = ApiDBUtils.findDomainById(account.getDomainId());
|
|
response.setAllocatedInDomainId(domain.getUuid());
|
|
}
|
|
|
|
response.setAllocatedTime(portableIp.getAllocatedTime());
|
|
|
|
if (portableIp.getAssociatedDataCenterId() != null) {
|
|
DataCenter zone = ApiDBUtils.findZoneById(portableIp.getAssociatedDataCenterId());
|
|
if (zone != null) {
|
|
response.setAssociatedDataCenterId(zone.getUuid());
|
|
}
|
|
}
|
|
|
|
if (portableIp.getPhysicalNetworkId() != null) {
|
|
PhysicalNetwork pnw = ApiDBUtils.findPhysicalNetworkById(portableIp.getPhysicalNetworkId());
|
|
if (pnw != null) {
|
|
response.setPhysicalNetworkId(pnw.getUuid());
|
|
}
|
|
}
|
|
|
|
if (portableIp.getAssociatedWithNetworkId() != null) {
|
|
Network ntwk = ApiDBUtils.findNetworkById(portableIp.getAssociatedWithNetworkId());
|
|
if (ntwk != null) {
|
|
response.setAssociatedWithNetworkId(ntwk.getUuid());
|
|
}
|
|
}
|
|
|
|
if (portableIp.getAssociatedWithVpcId() != null) {
|
|
Vpc vpc = ApiDBUtils.findVpcById(portableIp.getAssociatedWithVpcId());
|
|
if (vpc != null) {
|
|
response.setAssociatedWithVpcId(vpc.getUuid());
|
|
}
|
|
}
|
|
|
|
response.setState(portableIp.getState().name());
|
|
response.setObjectName("portableip");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public InternalLoadBalancerElementResponse createInternalLbElementResponse(VirtualRouterProvider result) {
|
|
if (result.getType() != VirtualRouterProvider.Type.InternalLbVm) {
|
|
return null;
|
|
}
|
|
InternalLoadBalancerElementResponse response = new InternalLoadBalancerElementResponse();
|
|
response.setId(result.getUuid());
|
|
PhysicalNetworkServiceProvider nsp = ApiDBUtils.findPhysicalNetworkServiceProviderById(result.getNspId());
|
|
if (nsp != null) {
|
|
response.setNspId(nsp.getUuid());
|
|
}
|
|
response.setEnabled(result.isEnabled());
|
|
|
|
response.setObjectName("internalloadbalancerelement");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public IsolationMethodResponse createIsolationMethodResponse(IsolationType method) {
|
|
IsolationMethodResponse response = new IsolationMethodResponse();
|
|
response.setIsolationMethodName(method.toString());
|
|
response.setObjectName("isolationmethod");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public NetworkACLResponse createNetworkACLResponse(NetworkACL networkACL) {
|
|
NetworkACLResponse response = new NetworkACLResponse();
|
|
response.setId(networkACL.getUuid());
|
|
response.setName(networkACL.getName());
|
|
response.setDescription(networkACL.getDescription());
|
|
response.setForDisplay(networkACL.isDisplay());
|
|
Vpc vpc = ApiDBUtils.findVpcById(networkACL.getVpcId());
|
|
if (vpc != null) {
|
|
response.setVpcId(vpc.getUuid());
|
|
}
|
|
response.setObjectName("networkacllist");
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public ListResponse<UpgradeRouterTemplateResponse> createUpgradeRouterTemplateResponse(List<Long> jobIds) {
|
|
ListResponse<UpgradeRouterTemplateResponse> response = new ListResponse<UpgradeRouterTemplateResponse>();
|
|
List<UpgradeRouterTemplateResponse> responses = new ArrayList<UpgradeRouterTemplateResponse>();
|
|
for (Long jobId : jobIds) {
|
|
UpgradeRouterTemplateResponse routerResponse = new UpgradeRouterTemplateResponse();
|
|
AsyncJob job = _entityMgr.findById(AsyncJob.class, jobId);
|
|
routerResponse.setAsyncJobId((job.getUuid()));
|
|
routerResponse.setObjectName("asyncjobs");
|
|
responses.add(routerResponse);
|
|
}
|
|
response.setResponses(responses);
|
|
return response;
|
|
}
|
|
|
|
@Override
|
|
public SSHKeyPairResponse createSSHKeyPairResponse(SSHKeyPair sshkeyPair, boolean privatekey) {
|
|
SSHKeyPairResponse response = new SSHKeyPairResponse(sshkeyPair.getName(), sshkeyPair.getFingerprint());
|
|
if (privatekey) {
|
|
response = new CreateSSHKeyPairResponse(sshkeyPair.getName(), sshkeyPair.getFingerprint(), sshkeyPair.getPrivateKey());
|
|
}
|
|
Account account = ApiDBUtils.findAccountById(sshkeyPair.getAccountId());
|
|
response.setAccountName(account.getAccountName());
|
|
Domain domain = ApiDBUtils.findDomainById(sshkeyPair.getDomainId());
|
|
response.setDomainId(domain.getUuid());
|
|
response.setDomainName(domain.getName());
|
|
return response;
|
|
}
|
|
}
|