com.abiquo.apiclient.CloudApi Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of api-java-client Show documentation
Show all versions of api-java-client Show documentation
Abiquo REST API Java client
The newest version!
/**
* Copyright (C) 2008 Abiquo Holdings S.L.
*
* Licensed 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.abiquo.apiclient;
import static com.abiquo.apiclient.AsyncTaskUtils.hasFinishedSuccesfully;
import static com.abiquo.apiclient.domain.ApiPath.ACTION_DEFAULT_VLAN;
import static com.abiquo.apiclient.domain.ApiPath.ACTION_PLANS_URL;
import static com.abiquo.apiclient.domain.ApiPath.RESOURCE_GROUPS_URL;
import static com.abiquo.apiclient.domain.ApiPath.VIRTUALDATACENTERS_URL;
import static com.abiquo.apiclient.domain.LinkRel.AVAILABILITY_SET;
import static com.abiquo.apiclient.domain.LinkRel.AVAILABILITY_SETS;
import static com.abiquo.apiclient.domain.LinkRel.ENTERPRISE;
import static com.abiquo.apiclient.domain.LinkRel.HYPERVISORTYPE;
import static com.abiquo.apiclient.domain.LinkRel.REGION;
import static com.abiquo.apiclient.domain.LinkRel.VIRTUALDATACENTER;
import static com.abiquo.apiclient.domain.Links.create;
import static com.abiquo.apiclient.domain.Links.editOrSelf;
import static com.abiquo.apiclient.domain.Links.isNic;
import static com.abiquo.apiclient.domain.Links.withRel;
import static com.abiquo.server.core.task.TaskState.FINISHED_SUCCESSFULLY;
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Collections.singletonMap;
import static java.util.Objects.requireNonNull;
import static java.util.Optional.empty;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import com.abiquo.apiclient.domain.ApiPath;
import com.abiquo.apiclient.domain.LinkRel;
import com.abiquo.apiclient.domain.exception.AsyncTaskFailedException;
import com.abiquo.apiclient.domain.options.AllowedDatacenterListOptions;
import com.abiquo.apiclient.domain.options.AllowedPublicCloudRegionListOptions;
import com.abiquo.apiclient.domain.options.EventListOptions;
import com.abiquo.apiclient.domain.options.ExternalIpListOptions;
import com.abiquo.apiclient.domain.options.ListOptions;
import com.abiquo.apiclient.domain.options.VirtualApplianceListOptions;
import com.abiquo.apiclient.domain.options.VirtualDatacenterListOptions;
import com.abiquo.apiclient.domain.options.VirtualMachineListOptions;
import com.abiquo.model.enumerator.NetworkType;
import com.abiquo.model.rest.RESTLink;
import com.abiquo.model.transport.AcceptedRequestDto;
import com.abiquo.model.transport.LinksDto;
import com.abiquo.model.transport.SingleResourceTransportDto;
import com.abiquo.server.core.appslibrary.VirtualMachineTemplateDto;
import com.abiquo.server.core.asynctask.AsyncTaskDto;
import com.abiquo.server.core.cloud.AddressRangesDto;
import com.abiquo.server.core.cloud.AvailabilitySetDto;
import com.abiquo.server.core.cloud.AvailabilityZoneDto;
import com.abiquo.server.core.cloud.AvailabilityZonesDto;
import com.abiquo.server.core.cloud.DeviceDto;
import com.abiquo.server.core.cloud.DevicesDto;
import com.abiquo.server.core.cloud.FirewallPoliciesDto;
import com.abiquo.server.core.cloud.FirewallPolicyDto;
import com.abiquo.server.core.cloud.FirewallRulesDto;
import com.abiquo.server.core.cloud.HardwareProfileDto;
import com.abiquo.server.core.cloud.HealthCheckDto;
import com.abiquo.server.core.cloud.HealthChecksDto;
import com.abiquo.server.core.cloud.HypervisorTypeDto;
import com.abiquo.server.core.cloud.IPSecVPNDto;
import com.abiquo.server.core.cloud.IPSecVPNsDto;
import com.abiquo.server.core.cloud.LoadBalancerAddressDto;
import com.abiquo.server.core.cloud.LoadBalancerAddressesDto;
import com.abiquo.server.core.cloud.LoadBalancerDto;
import com.abiquo.server.core.cloud.LoadBalancersDto;
import com.abiquo.server.core.cloud.NatIpDto;
import com.abiquo.server.core.cloud.NatIpsDto;
import com.abiquo.server.core.cloud.NatNetworkDto;
import com.abiquo.server.core.cloud.NatNetworksDto;
import com.abiquo.server.core.cloud.RegionDto;
import com.abiquo.server.core.cloud.RoutingRuleDto;
import com.abiquo.server.core.cloud.RoutingRulesDto;
import com.abiquo.server.core.cloud.SSLCertificateDto;
import com.abiquo.server.core.cloud.SyncVirtualDatacenterDto;
import com.abiquo.server.core.cloud.VPNTunnelStatusDto;
import com.abiquo.server.core.cloud.VirtualApplianceDto;
import com.abiquo.server.core.cloud.VirtualApplianceState;
import com.abiquo.server.core.cloud.VirtualAppliancesDto;
import com.abiquo.server.core.cloud.VirtualDatacenterDto;
import com.abiquo.server.core.cloud.VirtualDatacentersDto;
import com.abiquo.server.core.cloud.VirtualMachineCloneOptionsDto;
import com.abiquo.server.core.cloud.VirtualMachineDto;
import com.abiquo.server.core.cloud.VirtualMachineState;
import com.abiquo.server.core.cloud.VirtualMachineStateDto;
import com.abiquo.server.core.cloud.VirtualMachineTaskDto;
import com.abiquo.server.core.cloud.VirtualMachinesDto;
import com.abiquo.server.core.cloud.actionplan.ActionPlanDto;
import com.abiquo.server.core.cloud.actionplan.ActionPlanFlatDto;
import com.abiquo.server.core.cloud.actionplan.ActionPlansDto;
import com.abiquo.server.core.cloud.actionplan.ActionPlansFlatDto;
import com.abiquo.server.core.cloud.loadbalancer.ConditionalActionDto;
import com.abiquo.server.core.cloud.loadbalancer.ConditionalActionsDto;
import com.abiquo.server.core.cloud.loadbalancer.TargetDto;
import com.abiquo.server.core.cloud.loadbalancer.TargetGroupDto;
import com.abiquo.server.core.cloud.loadbalancer.TargetGroupsDto;
import com.abiquo.server.core.cloud.loadbalancer.TargetsDto;
import com.abiquo.server.core.cloud.resourcegroup.ResourceGroupDto;
import com.abiquo.server.core.cloud.resourcegroup.ResourceGroupsDto;
import com.abiquo.server.core.enterprise.EnterpriseDto;
import com.abiquo.server.core.event.EventDto;
import com.abiquo.server.core.event.EventsDto;
import com.abiquo.server.core.infrastructure.DatacenterDto;
import com.abiquo.server.core.infrastructure.DatacentersDto;
import com.abiquo.server.core.infrastructure.LocationDto;
import com.abiquo.server.core.infrastructure.PublicCloudRegionDto;
import com.abiquo.server.core.infrastructure.PublicCloudRegionsDto;
import com.abiquo.server.core.infrastructure.network.ExternalIpDto;
import com.abiquo.server.core.infrastructure.network.ExternalIpsDto;
import com.abiquo.server.core.infrastructure.network.GlobalNetworkDto;
import com.abiquo.server.core.infrastructure.network.GlobalNetworksDto;
import com.abiquo.server.core.infrastructure.network.GlobalSubnetDto;
import com.abiquo.server.core.infrastructure.network.GlobalSubnetsDto;
import com.abiquo.server.core.infrastructure.network.IpsBulkCreationDto;
import com.abiquo.server.core.infrastructure.network.NicDto;
import com.abiquo.server.core.infrastructure.network.NicsDto;
import com.abiquo.server.core.infrastructure.network.PrivateIpDto;
import com.abiquo.server.core.infrastructure.network.PublicIpDto;
import com.abiquo.server.core.infrastructure.network.PublicIpsDto;
import com.abiquo.server.core.infrastructure.network.VLANNetworkDto;
import com.abiquo.server.core.infrastructure.network.VMNetworkConfigurationDto;
import com.abiquo.server.core.infrastructure.network.VMNetworkConfigurationsDto;
import com.abiquo.server.core.infrastructure.storage.DiskManagementDto;
import com.abiquo.server.core.infrastructure.storage.DisksManagementDto;
import com.abiquo.server.core.infrastructure.storage.TierDto;
import com.abiquo.server.core.infrastructure.storage.TiersDto;
import com.abiquo.server.core.infrastructure.storage.VolumeManagementDto;
import com.abiquo.server.core.infrastructure.storage.VolumesManagementDto;
import com.abiquo.server.core.task.TaskDto;
import com.abiquo.server.core.task.TasksDto;
public class CloudApi
{
private final RestClient client;
// Package private constructor to be used only by the ApiClient
CloudApi(final RestClient client)
{
this.client = requireNonNull(client, "client cannot be null");
}
public VirtualDatacenterDto getVirtualDatacenter(final int id)
{
return client.get(VIRTUALDATACENTERS_URL + "/" + id, VirtualDatacenterDto.MEDIA_TYPE,
VirtualDatacenterDto.class);
}
public VirtualDatacenterDto editVirtualDatacenter(final VirtualDatacenterDto vdc)
{
return client.edit(vdc);
}
public Stream listAllowedDatacenters()
{
return client.list(ApiPath.LOCATIONS_URL, DatacentersDto.MEDIA_TYPE, DatacentersDto.class);
}
public Stream listAllowedDatacenters(final AllowedDatacenterListOptions options)
{
return client.list(ApiPath.LOCATIONS_URL, options.queryParams(), DatacentersDto.MEDIA_TYPE,
DatacentersDto.class);
}
public Stream listEvents()
{
return client.list(ApiPath.EVENTS_URL, EventsDto.MEDIA_TYPE, EventsDto.class);
}
public Stream listEvents(final EventListOptions options)
{
return client.list(ApiPath.EVENTS_URL, options.queryParams(), EventsDto.MEDIA_TYPE,
EventsDto.class);
}
public Stream listAllowedPublicCloudRegions()
{
return client.list(ApiPath.LOCATIONS_URL, PublicCloudRegionsDto.MEDIA_TYPE,
PublicCloudRegionsDto.class);
}
public Stream listAllowedPublicCloudRegions(
final AllowedPublicCloudRegionListOptions options)
{
return client.list(ApiPath.LOCATIONS_URL, options.queryParams(),
PublicCloudRegionsDto.MEDIA_TYPE, PublicCloudRegionsDto.class);
}
public Stream listAvailabiltyZones(final PublicCloudRegionDto pcrLocation)
{
RESTLink restLink = pcrLocation.searchLink(LinkRel.AVAILABILITY_ZONES);
if (restLink == null)
{
return Stream.empty();
}
return client.list(restLink.getHref(), AvailabilityZonesDto.MEDIA_TYPE,
AvailabilityZonesDto.class);
}
public Stream listVirtualDatacenters()
{
return client.list(VIRTUALDATACENTERS_URL, VirtualDatacentersDto.MEDIA_TYPE,
VirtualDatacentersDto.class);
}
public Stream listVirtualDatacenters(
final VirtualDatacenterListOptions options)
{
return client.list(VIRTUALDATACENTERS_URL, options.queryParams(),
VirtualDatacentersDto.MEDIA_TYPE, VirtualDatacentersDto.class);
}
public Stream listExternalIps(final VirtualDatacenterDto vdc)
{
return client.list(vdc.searchLink("externalips").getHref(), ExternalIpsDto.MEDIA_TYPE,
ExternalIpsDto.class);
}
public Stream listExternalIps(final VirtualDatacenterDto vdc,
final ExternalIpListOptions options)
{
return client.list(vdc.searchLink("externalips").getHref(), options.queryParams(),
ExternalIpsDto.MEDIA_TYPE, ExternalIpsDto.class);
}
public Stream listVirtualAppliances(final VirtualDatacenterDto vdc)
{
return client.list(vdc.searchLink("virtualappliances").getHref(),
VirtualAppliancesDto.MEDIA_TYPE, VirtualAppliancesDto.class);
}
public Stream listVirtualAppliances(final VirtualDatacenterDto vdc,
final VirtualApplianceListOptions options)
{
return client.list(vdc.searchLink("virtualappliances").getHref(), options.queryParams(),
VirtualAppliancesDto.MEDIA_TYPE, VirtualAppliancesDto.class);
}
public VirtualApplianceDto getVirtualAppliance(final int idVdc, final int idVapp)
{
return client.get(
String.format("%s/%s/virtualappliances/%s", VIRTUALDATACENTERS_URL, idVdc, idVapp),
VirtualApplianceDto.MEDIA_TYPE, VirtualApplianceDto.class);
}
public Stream listVirtualMachines(final VirtualApplianceDto vapp)
{
return client.list(vapp.searchLink("virtualmachines").getHref(),
VirtualMachinesDto.MEDIA_TYPE, VirtualMachinesDto.class);
}
public Stream listVirtualMachines(final VirtualApplianceDto vapp,
final VirtualMachineListOptions options)
{
return client.list(vapp.searchLink("virtualmachines").getHref(), options.queryParams(),
VirtualMachinesDto.MEDIA_TYPE, VirtualMachinesDto.class);
}
public VLANNetworkDto getPrivateNetwork(final VirtualDatacenterDto vdc, final int idNetwork)
{
return client.get(vdc.searchLink(LinkRel.PRIVATE_NETWORKS).getHref() + "/" + idNetwork,
VLANNetworkDto.MEDIA_TYPE, VLANNetworkDto.class);
}
public VLANNetworkDto createPrivateNetwork(final VirtualDatacenterDto vdc,
final VLANNetworkDto privateNetwork)
{
return client.post(vdc.searchLink(LinkRel.PRIVATE_NETWORKS).getHref(),
VLANNetworkDto.MEDIA_TYPE, VLANNetworkDto.MEDIA_TYPE, privateNetwork,
VLANNetworkDto.class);
}
public Stream listNetworkConfigurations(final VirtualMachineDto vm)
{
return client.list(vm.searchLink("configurations").getHref(),
VMNetworkConfigurationsDto.MEDIA_TYPE, VMNetworkConfigurationsDto.class);
}
public VirtualMachineDto getVirtualMachine(final VirtualApplianceDto vapp, final int idVm)
{
return client.get(vapp.searchLink("virtualmachines").getHref() + "/" + idVm,
VirtualMachineDto.MEDIA_TYPE, VirtualMachineDto.class);
}
public VirtualDatacenterDto createVirtualDatacenter(final SingleResourceTransportDto location,
final EnterpriseDto enterprise, final String name, final String type,
final String vlanAddress, final String vlanGateway, final String vlanName,
final long pollInterval, final long maxWait, final TimeUnit timeUnit)
throws TimeoutException, AsyncTaskFailedException
{
VLANNetworkDto vlan = new VLANNetworkDto();
vlan.setAddress(vlanAddress);
vlan.setGateway(vlanGateway);
vlan.setMask(24);
vlan.setName(vlanName);
vlan.setType(NetworkType.INTERNAL);
return createVirtualDatacenter(location, enterprise, name, type, vlan, pollInterval,
maxWait, timeUnit);
}
public VirtualDatacenterDto createVirtualDatacenter(final SingleResourceTransportDto location,
final EnterpriseDto enterprise, final String name, final String type,
final VLANNetworkDto vlan, final long pollInterval, final long maxWait,
final TimeUnit timeUnit) throws TimeoutException, AsyncTaskFailedException
{
return createVirtualDatacenter(location, enterprise, name, type, vlan, empty(),
pollInterval, maxWait, timeUnit);
}
public VirtualDatacenterDto createVirtualDatacenter(final SingleResourceTransportDto location,
final EnterpriseDto enterprise, final String name, final String type,
final VLANNetworkDto vlan, final java.util.Optional addressRanges,
final long pollInterval, final long maxWait, final TimeUnit timeUnit)
throws TimeoutException, AsyncTaskFailedException
{
return createVirtualDatacenterWithResourceGroup(location, enterprise, name, type, vlan,
addressRanges, null, pollInterval, maxWait, timeUnit);
}
public VirtualDatacenterDto createVirtualDatacenterWithResourceGroup(
final SingleResourceTransportDto location, final EnterpriseDto enterprise,
final String name, final String type, final VLANNetworkDto vlan,
final java.util.Optional addressRanges,
final ResourceGroupDto resourceGroup, final long pollInterval, final long maxWait,
final TimeUnit timeUnit) throws TimeoutException, AsyncTaskFailedException
{
checkArgument(
location instanceof DatacenterDto || location instanceof PublicCloudRegionDto);
String mt = location instanceof DatacenterDto ? DatacenterDto.SHORT_MEDIA_TYPE_JSON
: PublicCloudRegionDto.SHORT_MEDIA_TYPE_JSON;
VirtualDatacenterDto vdc = new VirtualDatacenterDto();
vdc.setName(name);
vdc.setHypervisorType(type);
vdc.setVlan(vlan);
addressRanges.ifPresent(vdc::setAddressRanges);
vdc.addLink(create("enterprise", enterprise.getEditLink().getHref(),
EnterpriseDto.SHORT_MEDIA_TYPE_JSON));
RESTLink locationLink = java.util.Optional.ofNullable(location.searchLink("location"))
.orElseGet(() -> location.searchLink("self"));
vdc.addLink(create("location", locationLink.getHref(), mt, "datacenter"));
addResourceGroupLink(vdc, resourceGroup);
AsyncTaskDto task = client.post(VIRTUALDATACENTERS_URL, AsyncTaskDto.MEDIA_TYPE,
VirtualDatacenterDto.MEDIA_TYPE, vdc, AsyncTaskDto.class);
task = client.waitForAsyncTaskFinalization(task, pollInterval, maxWait, timeUnit);
if (!hasFinishedSuccesfully(task))
{
throw new AsyncTaskFailedException(task);
}
return client.get(task.searchLink("owner"), VirtualDatacenterDto.class);
}
public void deleteVirtualDatacenter(final SingleResourceTransportDto vdc,
final long pollInterval, final long maxWait, final TimeUnit timeUnit)
throws TimeoutException, AsyncTaskFailedException
{
AsyncTaskDto task = client.delete(vdc, AsyncTaskDto.MEDIA_TYPE, AsyncTaskDto.class);
task = client.waitForAsyncTaskFinalization(task, pollInterval, maxWait, timeUnit);
if (!hasFinishedSuccesfully(task))
{
throw new AsyncTaskFailedException(task);
}
}
public PublicIpDto createPublicIp(final PublicCloudRegionDto location)
{
return createPublicIp(location, new PublicIpDto());
}
public PublicIpDto createPublicIp(final PublicCloudRegionDto location,
final ResourceGroupDto resourceGroup)
{
PublicIpDto ip = new PublicIpDto();
addResourceGroupLink(ip, resourceGroup);
return createPublicIp(location, ip);
}
public PublicIpDto createPublicIp(final PublicCloudRegionDto location,
final String floatingIpType)
{
PublicIpDto publicIpDto = new PublicIpDto();
publicIpDto.setFloatingIpType(floatingIpType);
return createPublicIp(location, publicIpDto);
}
public PublicIpDto createPublicIp(final PublicCloudRegionDto location,
final PublicIpDto publicIpDto)
{
return client.post(location.searchLink("ips").getHref(), PublicIpDto.MEDIA_TYPE,
PublicIpDto.MEDIA_TYPE, publicIpDto, PublicIpDto.class);
}
public void createMultipleIPsExternalNetwork(final VLANNetworkDto extNetDto,
final String starterIP, final int nIPs)
{
IpsBulkCreationDto ipsConf = new IpsBulkCreationDto();
ipsConf.setIp(starterIP);
ipsConf.setAvailable(true);
ipsConf.setNumips(nIPs);
client.post(extNetDto.searchLink("ips").getHref(), ExternalIpsDto.MEDIA_TYPE,
IpsBulkCreationDto.MEDIA_TYPE, ipsConf, ExternalIpsDto.class);
}
public PublicIpDto addPublicIpToVirtualDatacenter(final PublicIpDto publicip,
final VirtualDatacenterDto vdc)
{
return client.put(vdc.searchLink("purchased").getHref() + "/" + publicip.getId(),
PublicIpDto.MEDIA_TYPE, PublicIpDto.class);
}
public PublicIpDto releasePublicIpFromVirtualDatacenter(final PublicIpDto publicip,
final VirtualDatacenterDto vdc)
{
return client.put(vdc.searchLink("topurchase").getHref() + "/" + publicip.getId(),
PublicIpDto.MEDIA_TYPE, PublicIpDto.class);
}
public VirtualMachineDto assignPublicIpToVirtualMachine(final PublicIpDto ip,
final VirtualDatacenterDto vdc, final VirtualMachineDto vm, final int pollInterval,
final int maxWait, final TimeUnit timeUnit)
{
int nics = (int) vm.getLinks().stream().filter(isNic()).count();
RESTLink nicLink = create(NicDto.REL_PREFIX + nics,
vdc.searchLink("purchased").getHref() + "/" + ip.getId(),
PublicIpDto.SHORT_MEDIA_TYPE_JSON);
vm.addLink(nicLink);
return editVirtualMachineCheckTask(vm, pollInterval, maxWait, timeUnit);
}
public VirtualMachineDto assignAvailabilitySetToVirtualMachine(
final AvailabilitySetDto availabilitySet, final VirtualMachineDto vm,
final int pollInterval, final int maxWait, final TimeUnit timeUnit)
{
vm.modifyLink(AVAILABILITY_SET, availabilitySet.getEditLink().getHref());
return editVirtualMachineCheckTask(vm, pollInterval, maxWait, timeUnit);
}
public VirtualApplianceDto createVirtualAppliance(final VirtualDatacenterDto vdc,
final String name)
{
VirtualApplianceDto vapp = new VirtualApplianceDto();
vapp.setName(name);
return client.post(vdc.searchLink("virtualappliances").getHref(),
VirtualApplianceDto.MEDIA_TYPE, VirtualApplianceDto.MEDIA_TYPE, vapp,
VirtualApplianceDto.class);
}
public VirtualMachineDto createVirtualMachine(final VirtualMachineDto vm,
final VirtualApplianceDto vapp)
{
return client.post(vapp.searchLink(LinkRel.VIRTUALMACHINES).getHref(),
VirtualMachineDto.MEDIA_TYPE, VirtualMachineDto.MEDIA_TYPE, vm,
VirtualMachineDto.class);
}
public VirtualMachineDto createVirtualMachine(final VirtualMachineTemplateDto template,
final VirtualApplianceDto vapp)
{
VirtualMachineDto vm = new VirtualMachineDto();
vm.setVdrpEnabled(Boolean.TRUE);
vm.addLink(withRel("virtualmachinetemplate", template.getEditLink()));
return client.post(vapp.searchLink("virtualmachines").getHref(),
VirtualMachineDto.MEDIA_TYPE, VirtualMachineDto.MEDIA_TYPE, vm,
VirtualMachineDto.class);
}
private VirtualMachineDto createVirtualMachineWithOtherRelations(
final VirtualMachineTemplateDto template, final VirtualApplianceDto vapp,
final java.util.Optional fw,
final java.util.Optional hp,
final java.util.Optional availabiltySet, final String name,
final ResourceGroupDto resourceGroup)
{
VirtualMachineDto vm = new VirtualMachineDto();
vm.setVdrpEnabled(Boolean.TRUE);
vm.setName(name);
vm.addLink(withRel("virtualmachinetemplate", template.getEditLink()));
hp.ifPresent(hwp -> vm.addLink(withRel("hardwareprofile", editOrSelf(hwp))));
fw.ifPresent(fwp -> vm.addLink(withRel("firewall", fwp.getEditLink())));
availabiltySet.ifPresent(as -> vm.addLink(withRel(AVAILABILITY_SET, as.getEditLink())));
addResourceGroupLink(vm, resourceGroup);
return client.post(vapp.searchLink("virtualmachines").getHref(),
VirtualMachineDto.MEDIA_TYPE, VirtualMachineDto.MEDIA_TYPE, vm,
VirtualMachineDto.class);
}
public VirtualMachineDto createVirtualMachineWithFirewall(
final VirtualMachineTemplateDto template, final VirtualApplianceDto vapp,
final FirewallPolicyDto fw, final HardwareProfileDto hp)
{
return createVirtualMachineWithFirewallAndLabel(template, vapp, fw, hp, null);
}
public VirtualMachineDto createVirtualMachineWithFirewallAndLabel(
final VirtualMachineTemplateDto template, final VirtualApplianceDto vapp,
final FirewallPolicyDto fw, final HardwareProfileDto hp, final String label)
{
return createVirtualMachineWithOtherRelations(template, vapp, java.util.Optional.of(fw),
java.util.Optional.of(hp), empty(), label, null);
}
public VirtualMachineDto createVirtualMachine(final VirtualMachineTemplateDto template,
final VirtualApplianceDto vapp, final HardwareProfileDto hp,
final java.util.Optional availabilitySet)
{
return createVirtualMachineWithLabel(template, vapp, hp, availabilitySet, null);
}
public VirtualMachineDto createVirtualMachineWithLabel(final VirtualMachineTemplateDto template,
final VirtualApplianceDto vapp, final HardwareProfileDto hp,
final java.util.Optional availabiltySet, final String label)
{
return createVirtualMachineWithLabelAndResourceGroup(template, vapp, hp, availabiltySet,
label, null);
}
public VirtualMachineDto createVirtualMachineWithLabelAndResourceGroup(
final VirtualMachineTemplateDto template, final VirtualApplianceDto vapp,
final HardwareProfileDto hp, final java.util.Optional availabiltySet,
final String label, final ResourceGroupDto resourceGroup)
{
return createVirtualMachineWithOtherRelations(template, vapp, empty(),
java.util.Optional.of(hp), availabiltySet, label, resourceGroup);
}
public VirtualMachineDto createVirtualMachine(final VirtualMachineTemplateDto template,
final VirtualApplianceDto vapp, final HardwareProfileDto hp)
{
return createVirtualMachine(template, vapp, hp, empty());
}
public VirtualMachineDto deploy(final VirtualMachineDto vm, final int pollInterval,
final int maxWait, final TimeUnit timeUnit)
{
return deployCheckTask(vm, false, pollInterval, maxWait, timeUnit);
}
public VirtualMachineDto deployCheckTask(final VirtualMachineDto vm, final boolean forceDeploy,
final int pollInterval, final int maxWait, final TimeUnit timeUnit)
{
if (vm.getState().isDeployed())
{
return vm;
}
AcceptedRequestDto acceptedRequest =
client.post(vm.searchLink(LinkRel.DEPLOY).getHref(), singletonMap("force", forceDeploy),
AcceptedRequestDto.MEDIA_TYPE, ApiClient.ACCEPTED_REQUEST_TYPE);
TaskDto task = client.waitForTask(acceptedRequest, pollInterval, maxWait, timeUnit);
if (FINISHED_SUCCESSFULLY != task.getState())
{
throw new RuntimeException("Deploy virtual machine task finished unsuccessfully");
}
return client.waitUntilUnlocked(vm, pollInterval, maxWait, timeUnit);
}
public VirtualApplianceDto deploy(final VirtualApplianceDto vapp, final int pollInterval,
final int maxWait, final TimeUnit timeUnit)
{
return deploy(vapp, false, pollInterval, maxWait, timeUnit);
}
public VirtualApplianceDto deploy(final VirtualApplianceDto vapp, final boolean forceDeploy,
final int pollInterval, final int maxWait, final TimeUnit timeUnit)
{
AcceptedRequestDto acceptedRequest = client.post(
vapp.searchLink(LinkRel.DEPLOY).getHref(), singletonMap("force", forceDeploy),
AcceptedRequestDto.MEDIA_TYPE, ApiClient.ACCEPTED_REQUEST_TYPE);
TaskDto task = client.waitForTask(acceptedRequest, pollInterval, maxWait, timeUnit);
if (FINISHED_SUCCESSFULLY != task.getState())
{
throw new RuntimeException("Deploy virtual appliance operation failed");
}
return client.waitUntilUnlocked(vapp, pollInterval, maxWait, timeUnit);
}
public VirtualMachineDto undeployCheckTask(final VirtualMachineDto vm,
final boolean forceUndeploy, final int pollInterval, final int maxWait,
final TimeUnit timeUnit)
{
if (!vm.getState().isDeployed())
{
return vm;
}
VirtualMachineTaskDto virtualMachineTask = new VirtualMachineTaskDto();
virtualMachineTask.setForceUndeploy(forceUndeploy);
AcceptedRequestDto acceptedRequest = client.post(
vm.searchLink(LinkRel.UNDEPLOY).getHref(), AcceptedRequestDto.MEDIA_TYPE,
VirtualMachineTaskDto.MEDIA_TYPE, virtualMachineTask, ApiClient.ACCEPTED_REQUEST_TYPE);
TaskDto task = client.waitForTask(acceptedRequest, pollInterval, maxWait, timeUnit);
if (FINISHED_SUCCESSFULLY != task.getState())
{
throw new RuntimeException("Undeploy virtual machine operation failed");
}
return client.waitUntilUnlocked(vm, pollInterval, maxWait, timeUnit);
}
public VirtualMachineDto undeploy(final VirtualMachineDto vm, final int pollInterval,
final int maxWait, final TimeUnit timeUnit)
{
return undeployCheckTask(vm, false, pollInterval, maxWait, timeUnit);
}
public VirtualApplianceDto undeploy(final VirtualApplianceDto vapp, final boolean forceUndeploy,
final int pollInterval, final int maxWait, final TimeUnit timeUnit)
{
if (vapp.getState().equals(VirtualApplianceState.NOT_DEPLOYED))
{
return vapp;
}
VirtualMachineTaskDto virtualMachineTask = new VirtualMachineTaskDto();
virtualMachineTask.setForceUndeploy(forceUndeploy);
AcceptedRequestDto acceptedRequest = client.post(
vapp.searchLink(LinkRel.UNDEPLOY).getHref(), AcceptedRequestDto.MEDIA_TYPE,
VirtualMachineTaskDto.MEDIA_TYPE, virtualMachineTask, ApiClient.ACCEPTED_REQUEST_TYPE);
TaskDto task = client.waitForTask(acceptedRequest, pollInterval, maxWait, timeUnit);
if (FINISHED_SUCCESSFULLY != task.getState())
{
throw new RuntimeException("Undeploy virtual appliance operation failed");
}
VirtualApplianceDto refreshed =
client.waitUntilUnlocked(vapp, pollInterval, maxWait, timeUnit);
if (VirtualApplianceState.NOT_DEPLOYED != refreshed.getState()
&& VirtualApplianceState.EMPTY != refreshed.getState())
{
throw new RuntimeException("Undeploy virtual appliance operation failed");
}
return refreshed;
}
public VirtualApplianceDto undeploy(final VirtualApplianceDto vapp, final int pollInterval,
final int maxWait, final TimeUnit timeUnit)
{
return undeploy(vapp, false, pollInterval, maxWait, timeUnit);
}
public VirtualMachineDto powerState(final VirtualMachineDto vm, final VirtualMachineState state,
final int pollInterval, final int maxWait, final TimeUnit timeUnit)
{
VirtualMachineStateDto vmState = new VirtualMachineStateDto();
vmState.setState(state);
AcceptedRequestDto acceptedRequest =
client.put(vm.searchLink("state").getHref(), AcceptedRequestDto.MEDIA_TYPE,
VirtualMachineStateDto.MEDIA_TYPE, vmState, ApiClient.ACCEPTED_REQUEST_TYPE);
TaskDto task = client.waitForTask(acceptedRequest, pollInterval, maxWait, timeUnit);
if (FINISHED_SUCCESSFULLY != task.getState())
{
throw new RuntimeException(
"Virtual machine power state '" + state.name() + "' operation failed");
}
return client.waitUntilUnlocked(vm, pollInterval, maxWait, timeUnit);
}
public VirtualMachineDto editVirtualMachineCheckTask(final VirtualMachineDto vm,
final int pollInterval, final int maxWait, final TimeUnit timeUnit)
{
VirtualMachineDto refreshed = null;
VirtualMachineState originalState = vm.getState();
if (vm.getState().isDeployed())
{
AcceptedRequestDto acceptedRequest =
client.put(vm.getEditLink().getHref(), AcceptedRequestDto.MEDIA_TYPE,
VirtualMachineDto.MEDIA_TYPE, vm, ApiClient.ACCEPTED_REQUEST_TYPE);
TaskDto task = client.waitForTask(acceptedRequest, pollInterval, maxWait, timeUnit);
if (FINISHED_SUCCESSFULLY != task.getState())
{
throw new RuntimeException("Virtual machine reconfigure operation failed");
}
refreshed = client.waitUntilUnlocked(vm, pollInterval, maxWait, timeUnit);
if (originalState != refreshed.getState())
{
throw new RuntimeException(
"Virtual machine reconfigure operation failed: " + refreshed.getState());
}
}
else
{
client.put(vm.getEditLink().getHref(), AcceptedRequestDto.MEDIA_TYPE,
VirtualMachineDto.MEDIA_TYPE, vm);
refreshed = client.refresh(vm);
}
return refreshed;
}
public VolumeManagementDto getVolume(final VirtualDatacenterDto vdc, final int idVolume)
{
return client.get(vdc.searchLink("volumes").getHref() + "/" + idVolume,
VolumeManagementDto.MEDIA_TYPE, VolumeManagementDto.class);
}
public VolumeManagementDto createVolume(final VirtualDatacenterDto vdc, final String name,
final long sizeInMb, final TierDto tier)
{
return createVolume(vdc, name, sizeInMb, tier, empty());
}
public VolumeManagementDto createVolume(final VirtualDatacenterDto vdc, final String name,
final long sizeInMb, final TierDto tier,
final java.util.Optional availabilityZone)
{
return createVolumeWithResourceGroup(vdc, name, sizeInMb, tier, availabilityZone, null);
}
public VolumeManagementDto createVolumeWithResourceGroup(final VirtualDatacenterDto vdc,
final String name, final long sizeInMb, final TierDto tier,
final java.util.Optional availabilityZone,
final ResourceGroupDto resourceGroup)
{
VolumeManagementDto dto = new VolumeManagementDto();
dto.setName(name);
dto.setSizeInMB(sizeInMb);
dto.addLink(create(LinkRel.TIER, editOrSelf(tier).getHref(), TierDto.MEDIA_TYPE));
availabilityZone
.ifPresent(availabilityZoneDto -> dto.addLink(create(LinkRel.AVAILABILITY_ZONE,
editOrSelf(availabilityZoneDto).getHref(), AvailabilityZoneDto.MEDIA_TYPE)));
addResourceGroupLink(dto, resourceGroup);
return client.post(vdc.searchLink("volumes").getHref(), VolumeManagementDto.MEDIA_TYPE,
VolumeManagementDto.MEDIA_TYPE, dto, VolumeManagementDto.class);
}
public TaskDto getTask(final VirtualMachineDto vm, final String idTask)
{
return client.get(vm.searchLink("tasks").getHref() + "/" + idTask, TaskDto.MEDIA_TYPE,
TaskDto.class);
}
public Stream listTiers(final VirtualDatacenterDto vdc)
{
return client.list(vdc.searchLink("tiers").getHref(), TiersDto.MEDIA_TYPE, TiersDto.class);
}
public Stream listDevices(final LocationDto location)
{
for (RESTLink link : location.getLinks())
{
if (link.getRel().equals("devices") && link.getType().equals(DevicesDto.MEDIA_TYPE))
{
return client.list(link.getHref(), DevicesDto.MEDIA_TYPE, DevicesDto.class);
}
}
return Stream.empty();
}
public Stream listVolumes(final VirtualDatacenterDto vdc)
{
return client.list(vdc.searchLink("volumes").getHref(), VolumesManagementDto.MEDIA_TYPE,
VolumesManagementDto.class);
}
public Stream listVolumesWithAvailability(final VirtualDatacenterDto vdc,
final Boolean availability)
{
return client.list(
vdc.searchLink("volumes").getHref() + "?available=" + availability.toString(),
VolumesManagementDto.MEDIA_TYPE, VolumesManagementDto.class);
}
public Stream listDevicesInLocation(final LocationDto location)
{
for (RESTLink link : location.getLinks())
{
if (link.getRel().equals("devices") && link.getType().equals(DevicesDto.MEDIA_TYPE)
&& link.getHref().contains("/locations/"))
{
return client.list(link.getHref(), DevicesDto.MEDIA_TYPE, DevicesDto.class);
}
}
return Stream.empty();
}
public Stream listLoadBalancers(final VirtualDatacenterDto vdc)
{
return client.list(vdc.searchLink("loadbalancers").getHref(), LoadBalancersDto.MEDIA_TYPE,
LoadBalancersDto.class);
}
public Stream listLoadBalancers(final DeviceDto lbd)
{
return client.list(lbd.searchLink("loadbalancers").getHref(), LoadBalancersDto.MEDIA_TYPE,
LoadBalancersDto.class);
}
public LoadBalancerDto getLoadBalacer(final DeviceDto device, final int idLoadBalancer)
{
return client.get(device.searchLink("loadbalancers").getHref() + "/" + idLoadBalancer,
LoadBalancerDto.MEDIA_TYPE, LoadBalancerDto.class);
}
public void deleteLoadBalancer(final LoadBalancerDto lbd)
{
client.delete(lbd);
}
public LoadBalancerDto editLoadBalancer(final LoadBalancerDto lbd)
{
return client.edit(lbd);
}
public LoadBalancerDto createLoadBalancer(final DeviceDto device, final String name,
final String algorithm, final List routingRules,
final List healthChecks, final List lbAddresses,
final List firewalls, final java.util.Optional vdc,
final java.util.Optional network)
{
return createLoadBalancer(device, name, null, algorithm, routingRules, healthChecks,
lbAddresses, firewalls, vdc,
network.isPresent() ? Collections.singletonList(network.get()) : null, null);
}
public LoadBalancerDto createLoadBalancer(final DeviceDto device, final String name,
final String type, final String algorithm, final List routingRules,
final List healthChecks, final List lbAddresses,
final List firewalls, final java.util.Optional vdc,
final List networks, final ResourceGroupDto resourceGroupDto)
{
LoadBalancerDto lbd = new LoadBalancerDto();
lbd.setName(name);
lbd.setAlgorithm(algorithm);
lbd.setType(type);
lbd.setHealthChecks(new HealthChecksDto());
lbd.setRoutingRules(new RoutingRulesDto());
lbd.setLoadBalancerAddresses(new LoadBalancerAddressesDto());
lbd.getHealthChecks().addAll(healthChecks);
lbd.getRoutingRules().addAll(routingRules);
lbd.getLoadBalancerAddresses().addAll(lbAddresses);
if (vdc.isPresent())
{
lbd.addLink(withRel("virtualdatacenter", editOrSelf(vdc.get())));
}
if (networks != null && !networks.isEmpty())
{
networks.forEach(network -> {
checkArgument(network.getType() == NetworkType.INTERNAL,
"Only internal networks can be assigned to a load balancer");
lbd.addLink(withRel("privatenetwork", editOrSelf(network)));
});
}
for (FirewallPolicyDto fw : firewalls)
{
lbd.addLink(withRel("firewall", editOrSelf(fw)));
}
addResourceGroupLink(lbd, resourceGroupDto);
return client.post(device.searchLink("loadbalancers").getHref(), LoadBalancerDto.MEDIA_TYPE,
LoadBalancerDto.MEDIA_TYPE, lbd, LoadBalancerDto.class);
}
private void addResourceGroupLink(final SingleResourceTransportDto dto,
final ResourceGroupDto resourceGroupDto)
{
if (resourceGroupDto != null)
{
dto.addLink(withRel(LinkRel.RESOURCE_GROUP, editOrSelf(resourceGroupDto)));
}
}
public HealthCheckDto createHealthCheck(final LoadBalancerDto lbd, final String name,
final String protocol, final long intervalInMs, final long timeoutInMs,
final Integer attemps, final Integer port, final String path)
{
HealthCheckDto healthCheck = new HealthCheckDto();
healthCheck.setName(name);
healthCheck.setProtocol(protocol);
healthCheck.setIntervalInMs(intervalInMs);
healthCheck.setTimeoutInMs(timeoutInMs);
healthCheck.setAttempts(attemps);
healthCheck.setPort(port);
healthCheck.setPath(path);
return client.post(lbd.searchLink("healthchecks").getHref(), HealthCheckDto.MEDIA_TYPE,
HealthCheckDto.MEDIA_TYPE, healthCheck, HealthCheckDto.class);
}
public RoutingRuleDto createRoutingRule(final LoadBalancerDto lbd, final String protocolIn,
final String protocolOut, final int portIn, final int portOut,
final SSLCertificateDto sslCertificate)
{
RoutingRuleDto routingRule = new RoutingRuleDto();
routingRule.setPortIn(portIn);
routingRule.setPortOut(portOut);
routingRule.setProtocolIn(protocolIn);
routingRule.setProtocolOut(protocolOut);
if (sslCertificate != null)
{
routingRule.setSslCertificate(sslCertificate);
}
return client.post(lbd.searchLink("routingrules").getHref(), RoutingRuleDto.MEDIA_TYPE,
RoutingRuleDto.MEDIA_TYPE, routingRule, RoutingRuleDto.class);
}
public Stream listRoutingRules(final LoadBalancerDto lbd)
{
return client.list(lbd.searchLink("routingrules").getHref(), RoutingRulesDto.MEDIA_TYPE,
RoutingRulesDto.class);
}
public Stream listHealthChecks(final LoadBalancerDto lbd)
{
return client.list(lbd.searchLink("healthchecks").getHref(), HealthChecksDto.MEDIA_TYPE,
HealthChecksDto.class);
}
public RoutingRulesDto editRoutingRules(final RoutingRulesDto routingRules)
{
for (RoutingRuleDto routingRule : routingRules.getCollection())
{
editRoutingRule(routingRule);
}
return routingRules;
}
public HealthChecksDto editHealthChecks(final HealthChecksDto healthChecks)
{
for (HealthCheckDto healthCheck : healthChecks.getCollection())
{
editHealthCheck(healthCheck);
}
return healthChecks;
}
public void deleteRoutingRule(final RoutingRuleDto routingRule)
{
client.delete(routingRule);
}
public void deleteHealthCheck(final HealthCheckDto healthCheck)
{
client.delete(healthCheck);
}
public RoutingRuleDto editRoutingRule(final RoutingRuleDto routingRule)
{
return client.edit(routingRule);
}
public HealthCheckDto editHealthCheck(final HealthCheckDto healthCheck)
{
return client.edit(healthCheck);
}
public RoutingRuleDto getRoutingRule(final LoadBalancerDto lbd, final int idRoutingRule)
{
return client.get(lbd.searchLink("routingrules").getHref() + "/" + idRoutingRule,
RoutingRuleDto.MEDIA_TYPE, RoutingRuleDto.class);
}
public HealthCheckDto getHealthCheck(final LoadBalancerDto lbd, final int idHealthCheck)
{
return client.get(lbd.searchLink("healthchecks").getHref() + "/" + idHealthCheck,
HealthCheckDto.MEDIA_TYPE, HealthCheckDto.class);
}
public Stream listConditionalActions(final RoutingRuleDto routingRule)
{
return client.list(routingRule.searchLink(LinkRel.CONDITIONAL_ACTIONS).getHref(),
ConditionalActionsDto.MEDIA_TYPE, ConditionalActionsDto.class);
}
public ConditionalActionDto editConditionalAction(final ConditionalActionDto conditionalAction)
{
return client.edit(conditionalAction);
}
public FirewallPolicyDto createFirewallPolicy(final String name, final String description,
final DeviceDto firewallDevice, final Optional optVdc,
final boolean isVdcDefault)
{
return createFirewallPolicyWithResourceGroup(name, description, firewallDevice, optVdc,
isVdcDefault, null);
}
public FirewallPolicyDto createFirewallPolicyWithResourceGroup(final String name,
final String description, final DeviceDto firewallDevice,
final Optional optVdc, final boolean isVdcDefault,
final ResourceGroupDto resourceGroup)
{
FirewallPolicyDto firewall = new FirewallPolicyDto();
firewall.setName(name);
firewall.setDescription(description);
if (optVdc.isPresent())
{
firewall.addLink(withRel("virtualdatacenter", editOrSelf(optVdc.get())));
firewall.setVdcDefault(isVdcDefault);
}
addResourceGroupLink(firewall, resourceGroup);
return client.post(firewallDevice.searchLink("firewalls").getHref(),
FirewallPolicyDto.MEDIA_TYPE, FirewallPolicyDto.MEDIA_TYPE, firewall,
FirewallPolicyDto.class);
}
public Stream listFirewallPolicies(final DeviceDto device)
{
return client.list(device.searchLink("firewalls").getHref(), FirewallPoliciesDto.MEDIA_TYPE,
FirewallPoliciesDto.class);
}
public Stream listFirewallPolicies(final VirtualDatacenterDto vdc)
{
return client.list(vdc.searchLink(LinkRel.FIREWALLS).getHref(),
FirewallPoliciesDto.MEDIA_TYPE, FirewallPoliciesDto.class);
}
public FirewallPolicyDto makeThisFirewallPolicyDefaultForVirtualDatacenter(
final FirewallPolicyDto fw)
{
return client.put(fw.searchLink("defaultfirewallpolicy").getHref(),
FirewallPolicyDto.MEDIA_TYPE, FirewallPolicyDto.class);
}
public void deleteFirewallPolicies(final FirewallPolicyDto firewall)
{
client.delete(firewall);
}
public FirewallRulesDto addFirewallRules(final FirewallPolicyDto firewall,
final FirewallRulesDto rules)
{
return client.put(firewall.searchLink("rules").getHref(), FirewallRulesDto.MEDIA_TYPE,
FirewallRulesDto.MEDIA_TYPE, rules, FirewallRulesDto.class);
}
public VirtualMachineDto addFirewallToVirtualMachine(final FirewallPolicyDto firewall,
final VirtualMachineDto vm, final int pollInterval, final int maxWait,
final TimeUnit timeUnit)
{
vm.addLink(withRel("firewall", editOrSelf(firewall)));
return editVirtualMachineCheckTask(vm, pollInterval, maxWait, timeUnit);
}
public NicsDto getNics(final VirtualMachineDto vm)
{
return client.get(vm.searchLink("nics").getHref(), NicsDto.MEDIA_TYPE, NicsDto.class);
}
public VirtualMachineDto cloneVirtualMachine(final VirtualMachineDto vm)
{
return client.post(vm.searchLink("clone").getHref(), VirtualMachineDto.MEDIA_TYPE,
VirtualMachineCloneOptionsDto.MEDIA_TYPE, vm, VirtualMachineDto.class);
}
public IPSecVPNDto createIPSecVPN(final VirtualDatacenterDto vdc, final String name,
final String remoteEndpoint, final String encryptionAlgorithm,
final boolean perfectForwardSecrecyEnabled, final String dhGroup,
final String authentication, final Set remoteNetworks, final String presharedKey,
final Optional localEndpoint, final Optional> localNetworks,
final long pollInterval, final long maxWait, final TimeUnit timeUnit)
throws TimeoutException, AsyncTaskFailedException
{
IPSecVPNDto vpnIPSec = new IPSecVPNDto();
vpnIPSec.setName(name);
vpnIPSec.setRemoteEndpoint(remoteEndpoint);
vpnIPSec.setEncryptionAlgorithm(encryptionAlgorithm);
vpnIPSec.setPerfectForwardSecrecyEnabled(perfectForwardSecrecyEnabled);
vpnIPSec.setDhGroup(dhGroup);
vpnIPSec.setAuthentication(authentication);
vpnIPSec.setRemoteNetworks(remoteNetworks);
vpnIPSec.setPresharedKey(presharedKey);
vpnIPSec.addLink(withRel("localnetwork", vdc.getVlan().getEditLink()));
if (localEndpoint.isPresent())
{
vpnIPSec.addLink(withRel("localendpoint", localEndpoint.get()));
}
if (localNetworks.isPresent())
{
for (VLANNetworkDto vlan : localNetworks.get())
{
vpnIPSec.addLink(withRel("localnetwork", vlan.getEditLink()));
}
}
AsyncTaskDto task = client.post(vdc.searchLink("vpns").getHref(), AsyncTaskDto.MEDIA_TYPE,
IPSecVPNDto.MEDIA_TYPE, vpnIPSec, AsyncTaskDto.class);
task = client.waitForAsyncTaskFinalization(task, pollInterval, maxWait, timeUnit);
if (!hasFinishedSuccesfully(task))
{
throw new AsyncTaskFailedException(task);
}
return client.get(task.searchLink("owner"), IPSecVPNDto.class);
}
public Stream listIPSecVPN(final VirtualDatacenterDto vdc)
{
return client.list(vdc.searchLink("vpns").getHref(), IPSecVPNsDto.MEDIA_TYPE,
IPSecVPNsDto.class);
}
public IPSecVPNDto getIPSecVPN(final int idVdc, final int idVpn)
{
return client.get(String.format("%s/%s/vpns/%s", VIRTUALDATACENTERS_URL, idVdc, idVpn),
IPSecVPNDto.MEDIA_TYPE, IPSecVPNDto.class);
}
public void deleteIPSecVPN(final SingleResourceTransportDto vpn, final long pollInterval,
final long maxWait, final TimeUnit timeUnit)
throws TimeoutException, AsyncTaskFailedException
{
AsyncTaskDto task = client.delete(vpn, AsyncTaskDto.MEDIA_TYPE, AsyncTaskDto.class);
task = client.waitForAsyncTaskFinalization(task, pollInterval, maxWait, timeUnit);
if (!hasFinishedSuccesfully(task))
{
throw new AsyncTaskFailedException(task);
}
}
public IPSecVPNDto editIPSecVPNDto(final IPSecVPNDto vpn, final long pollInterval,
final long maxWait, final TimeUnit timeUnit)
throws TimeoutException, AsyncTaskFailedException
{
RESTLink link = vpn.getEditLink();
AsyncTaskDto task = client.put(link.getHref(), AsyncTaskDto.MEDIA_TYPE,
IPSecVPNDto.MEDIA_TYPE, vpn, AsyncTaskDto.class);
task = client.waitForAsyncTaskFinalization(task, pollInterval, maxWait, timeUnit);
if (!hasFinishedSuccesfully(task))
{
throw new AsyncTaskFailedException(task);
}
return client.get(task.searchLink("owner"), IPSecVPNDto.class);
}
public VPNTunnelStatusDto checkTunnelStatusOfAnIPSecVPN(final IPSecVPNDto vpn)
{
return client.get(vpn.searchLink("status"), VPNTunnelStatusDto.class);
}
public Stream listNatNetworksInADevice(final DeviceDto device)
{
return client.list(device.searchLink("natnetworks").getHref(), NatNetworksDto.MEDIA_TYPE,
NatNetworksDto.class);
}
public Stream listNatIPsInVirtualDatacenter(final VirtualDatacenterDto vdc)
{
return client.list(vdc.getEditLink().getHref() + "/action/natips", NatIpsDto.MEDIA_TYPE,
NatIpsDto.class);
}
public NatIpDto assignNatIPToVirtualDatacenter(final NatNetworkDto natNW,
final VirtualDatacenterDto vdc)
{
LinksDto links = new LinksDto();
links.addLink(
create("virtualdatacenter", vdc.getEditLink().getHref(), vdc.getEditLink().getType()));
return client.post(natNW.searchLink("ips").getHref(), NatIpDto.MEDIA_TYPE,
LinksDto.MEDIA_TYPE, links, NatIpDto.class);
}
public Stream syncFirewallPolicies(final VirtualDatacenterDto vdc)
{
Map queryParams = new HashMap<>();
queryParams.put("source", "REMOTE");
return client.list(vdc.searchLink("firewalls").getHref(), queryParams,
FirewallPoliciesDto.MEDIA_TYPE, FirewallPoliciesDto.class);
}
public VirtualMachineDto assignIpToVirtualMachine(final VirtualMachineDto vm,
final VLANNetworkDto vlan, final int pollInterval, final int maxWait,
final TimeUnit timeUnit)
{
int nics = (int) vm.getLinks().stream().filter(isNic()).count();
RESTLink ipLink = create(NicDto.REL_PREFIX + nics, vlan.searchLink("ips").getHref(),
PrivateIpDto.SHORT_MEDIA_TYPE_JSON, "newIP");
vm.addLink(ipLink);
return editVirtualMachineCheckTask(vm, pollInterval, maxWait, timeUnit);
}
public void syncVirtualDatacenter(final ApiClient api, final VirtualDatacenterDto vdc,
final int syncVDCPollInterval, final int syncVDCWaitTime, final TimeUnit syncVDCTimeUnit)
{
SyncVirtualDatacenterDto sync = new SyncVirtualDatacenterDto();
sync.addLink(vdc.searchLink("location"));
sync.setProviderId(vdc.getProviderId());
AcceptedRequestDto accepted =
api.getClient().post(VIRTUALDATACENTERS_URL, AcceptedRequestDto.MEDIA_TYPE,
SyncVirtualDatacenterDto.MEDIA_TYPE, sync, AcceptedRequestDto.class);
RESTLink taskLink = accepted.searchLink("status");
TaskDto task = api.getClient().get(taskLink, TaskDto.class);
client.waitForTask(task, syncVDCPollInterval, syncVDCWaitTime, syncVDCTimeUnit);
}
public DiskManagementDto createHardDisk(final VirtualDatacenterDto vdc,
final DiskManagementDto disk)
{
return client.post(vdc.searchLink(LinkRel.DISKS).getHref(), DiskManagementDto.MEDIA_TYPE,
DiskManagementDto.MEDIA_TYPE, disk, DiskManagementDto.class);
}
public Stream listHardDisks(final VirtualMachineDto vm)
{
return client.list(vm.searchLink(LinkRel.HARDDISKS), DisksManagementDto.class);
}
public VirtualMachineDto detachVolume(final VirtualMachineDto vm, final VolumeManagementDto vol)
{
return detachVolume(vm, vol, 5, 300, TimeUnit.SECONDS);
}
public VirtualMachineDto detachVolume(final VirtualMachineDto vm, final VolumeManagementDto vol,
final int pollInterval, final int maxWait, final TimeUnit timeUnit)
{
vm.getLinks().stream()
.filter(l -> VolumeManagementDto.MEDIA_TYPE.equals(l.getType())
&& l.getHref().equals(vol.getEditLink().getHref()))
.findFirst().ifPresent(vm.getLinks()::remove);
return editVirtualMachineCheckTask(vm, pollInterval, maxWait, timeUnit);
}
public VirtualMachineDto detachAllExternalIPs(final VirtualMachineDto vm)
{
return detachAllExternalIPs(vm, 5, 300, TimeUnit.SECONDS);
}
public VirtualMachineDto detachAllExternalIPs(final VirtualMachineDto vm,
final int pollInterval, final int maxWait, final TimeUnit timeUnit)
{
vm.getLinks().removeIf(l -> l.getType().equals(ExternalIpDto.SHORT_MEDIA_TYPE_JSON)
|| l.getRel().equals("network_configuration"));
return editVirtualMachineCheckTask(vm, pollInterval, maxWait, timeUnit);
}
public VirtualMachineDto attachVolume(final VirtualMachineDto vm, final VolumeManagementDto vol)
{
return attachVolume(vm, vol, 5, 300, TimeUnit.SECONDS);
}
public VirtualMachineDto attachVolume(final VirtualMachineDto vm, final VolumeManagementDto vol,
final int pollInterval, final int maxWait, final TimeUnit timeUnit)
{
int diskNumber;
List disks = StreamSupport.stream(vm.getLinks().spliterator(), false)
.filter(l -> l.getRel().startsWith("disk")).collect(Collectors.toList());
diskNumber = disks.size();
vm.addLink(withRel("disk" + diskNumber, editOrSelf(vol)));
return editVirtualMachineCheckTask(vm, pollInterval, maxWait, timeUnit);
}
public ActionPlanDto createActionPlan(final ActionPlanDto ap)
{
return client.post(ACTION_PLANS_URL, ActionPlanDto.MEDIA_TYPE, ActionPlanDto.MEDIA_TYPE, ap,
ActionPlanDto.class);
}
public Stream listActionPlans()
{
return client.list(ACTION_PLANS_URL, ActionPlansDto.MEDIA_TYPE, ActionPlansDto.class);
}
public Stream listActionPlansFlat()
{
return client.list(ACTION_PLANS_URL, ActionPlansFlatDto.MEDIA_TYPE,
ActionPlansFlatDto.class);
}
public ActionPlanDto editActionPlan(final ActionPlanDto ap)
{
return client.edit(ap);
}
public void deleteActionPlan(final ActionPlanDto ap)
{
client.delete(ap);
}
public Stream listTasksInActionPlan(final ActionPlanDto ap)
{
return client.list(ap.getEditLink().getHref() + "tasks", TasksDto.MEDIA_TYPE,
TasksDto.class);
}
public TaskDto executeActionPlanAndGetTask(final ActionPlanDto ap, final int pollInterval,
final int maxWait, final TimeUnit timeUnit)
{
AcceptedRequestDto acceptedRequest =
client.post(ap.getEditLink().getHref() + "/action/execute",
AcceptedRequestDto.MEDIA_TYPE, ApiClient.ACCEPTED_REQUEST_TYPE);
return client.waitForTask(acceptedRequest, pollInterval, maxWait, timeUnit);
}
public AvailabilitySetDto createAvailabilitySet(final PublicCloudRegionDto location,
final VirtualDatacenterDto vdc, final String name)
{
return createAvailabilitySetWithResourceGroup(location, vdc, name, null);
}
public AvailabilitySetDto createAvailabilitySetWithResourceGroup(
final PublicCloudRegionDto location, final VirtualDatacenterDto vdc, final String name,
final ResourceGroupDto resourceGroup)
{
AvailabilitySetDto dto = new AvailabilitySetDto();
dto.setName(name);
dto.setFaultDomains(2);
dto.setUpdateDomains(5);
dto.addLink(withRel(VIRTUALDATACENTER, editOrSelf(vdc)));
addResourceGroupLink(dto, resourceGroup);
return client.post(location.searchLink(AVAILABILITY_SETS).getHref(),
AvailabilitySetDto.MEDIA_TYPE, AvailabilitySetDto.MEDIA_TYPE, dto,
AvailabilitySetDto.class);
}
public void makeVlanDefault(final VirtualDatacenterDto vdc, final VLANNetworkDto vlan)
{
LinksDto links = new LinksDto();
links.addLink(withRel(vlan.getType().getRel(), vlan.getEditLink()));
client.putAction(vdc.getEditLink().getHref() + ACTION_DEFAULT_VLAN,
LinksDto.MEDIA_TYPE_JSON, links);
}
public void makeGlobalSubnetDefault(final VirtualDatacenterDto vdc,
final GlobalSubnetDto subnet)
{
LinksDto links = new LinksDto();
links.addLink(withRel(LinkRel.GLOBAL_SUBNET, editOrSelf(subnet)));
client.putAction(vdc.getEditLink().getHref() + ApiPath.ACTION_DEFAULT_GLOBAL_SUBNET,
LinksDto.MEDIA_TYPE_JSON, links);
}
public void createResourceGroup(final String resourceGroupName, final EnterpriseDto enterprise,
final RegionDto region)
{
ResourceGroupDto dto = new ResourceGroupDto();
dto.setName(resourceGroupName);
dto.addLink(withRel(ENTERPRISE, editOrSelf(enterprise)));
dto.addLink(withRel(REGION, editOrSelf(region)));
client.post(RESOURCE_GROUPS_URL, ResourceGroupDto.MEDIA_TYPE, ResourceGroupDto.MEDIA_TYPE,
dto, ResourceGroupDto.class);
}
public List listResourceGroups(final EnterpriseDto enterprise,
final HypervisorTypeDto plugin)
{
ListOptions options = ListOptions.builder().limit(0).build();
LinksDto links = new LinksDto();
links.addLink(withRel(ENTERPRISE, editOrSelf(enterprise)));
links.addLink(withRel(HYPERVISORTYPE, editOrSelf(plugin)));
return client.put(RESOURCE_GROUPS_URL, options.queryParams(), ResourceGroupsDto.MEDIA_TYPE,
LinksDto.MEDIA_TYPE, links, ResourceGroupsDto.class).getCollection();
}
public GlobalNetworkDto createGlobalNetwork(final String name, final EnterpriseDto enterprise,
final HypervisorTypeDto plugin)
{
GlobalNetworkDto dto = new GlobalNetworkDto();
dto.setName(name);
dto.addLink(withRel(ENTERPRISE, editOrSelf(enterprise)));
dto.addLink(withRel(HYPERVISORTYPE, editOrSelf(plugin)));
return client.post(ApiPath.GLOBAL_NETWORKS_URL, GlobalNetworkDto.MEDIA_TYPE,
GlobalNetworkDto.MEDIA_TYPE, dto, GlobalNetworkDto.class);
}
public List listGlobalNetworks(final EnterpriseDto enterprise,
final HypervisorTypeDto plugin)
{
ListOptions options = ListOptions.builder().limit(0).build();
LinksDto links = new LinksDto();
links.addLink(withRel(ENTERPRISE, editOrSelf(enterprise)));
links.addLink(withRel(HYPERVISORTYPE, editOrSelf(plugin)));
return client.post(ApiPath.GLOBAL_NETWORKS_URL, options.queryParams(),
GlobalNetworksDto.MEDIA_TYPE, LinksDto.MEDIA_TYPE, links, GlobalNetworksDto.class)
.getCollection();
}
public void deleteGlobalNetwork(final GlobalNetworkDto gn)
{
client.delete(gn);
}
public GlobalSubnetDto createGlobalSubnet(final String name, final String cidr,
final PublicCloudRegionDto location, final GlobalNetworkDto globalNetwork,
final VirtualDatacenterDto vdcDto)
{
GlobalSubnetDto dto = new GlobalSubnetDto();
dto.setName(name);
dto.setCidr(cidr);
dto.addLink(withRel(LinkRel.GLOBAL_NETWORK, editOrSelf(globalNetwork)));
dto.addLink(withRel(LinkRel.VIRTUALDATACENTER, editOrSelf(vdcDto)));
return client.post(location.searchLink(LinkRel.GLOBAL_SUBNETS).getHref(),
GlobalSubnetDto.MEDIA_TYPE, GlobalSubnetDto.MEDIA_TYPE, dto, GlobalSubnetDto.class);
}
public List listGlobalSubnets(final GlobalNetworkDto gn)
{
ListOptions options = ListOptions.builder().limit(0).build();
return client.get(gn.searchLink(LinkRel.GLOBAL_SUBNETS).getHref(), options.queryParams(),
GlobalSubnetsDto.MEDIA_TYPE, GlobalSubnetsDto.class).getCollection();
}
public void deleteGlobalSubnet(final GlobalSubnetDto subnet)
{
client.delete(subnet);
}
public List listPublicIPsOfLocation(final LocationDto pcrLocation)
{
return client.get(pcrLocation.searchLink(LinkRel.IPS).getHref(), PublicIpsDto.MEDIA_TYPE,
PublicIpsDto.class).getCollection();
}
public List listTargetGroups(final DeviceDto device)
{
return client.get(device.searchLink(LinkRel.TARGET_GROUPS), TargetGroupsDto.class)
.getCollection();
}
public List listTargetGroups(final VirtualDatacenterDto vdc)
{
return client.get(vdc.searchLink(LinkRel.TARGET_GROUPS), TargetGroupsDto.class)
.getCollection();
}
public TargetGroupDto createTargetGroup(final DeviceDto device,
final TargetGroupDto targetGroup)
{
return client.post(device.searchLink(LinkRel.TARGET_GROUPS).getHref(),
TargetGroupDto.MEDIA_TYPE, TargetGroupDto.MEDIA_TYPE, targetGroup,
TargetGroupDto.class);
}
public TargetGroupDto editTargetGroup(final TargetGroupDto targetGroup)
{
return client.edit(targetGroup);
}
public void deleteTargetGroup(final TargetGroupDto targetGoup)
{
client.delete(targetGoup);
}
public List updateTargetGroupTargets(final TargetGroupDto targetGroup,
final List newTargets)
{
TargetsDto dto = new TargetsDto();
dto.getCollection().addAll(newTargets);
return client.put(targetGroup.searchLink(LinkRel.TARGETS).getHref(), TargetsDto.MEDIA_TYPE,
TargetsDto.MEDIA_TYPE, dto, TargetsDto.class).getCollection();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy