com.abiquo.apiclient

Class CloudApi

java.lang.Object

com.abiquo.apiclient.CloudApi

public class CloudApi
extends Object

Method Summary

Modifier and Type	Method and Description
FirewallRulesDto	addFirewallRules(FirewallPolicyDto firewall, FirewallRulesDto rules)
VirtualMachineDto	addFirewallToVirtualMachine(FirewallPolicyDto firewall, VirtualMachineDto vm, int pollInterval, int maxWait, TimeUnit timeUnit)
PublicIpDto	addPublicIpToVirtualDatacenter(PublicIpDto publicip, VirtualDatacenterDto vdc)
VirtualMachineDto	assignAvailabilitySetToVirtualMachine(AvailabilitySetDto availabilitySet, PublicCloudRegionDto location, VirtualDatacenterDto vdc, VirtualMachineDto vm, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualMachineDto	assignIpToVirtualMachine(VirtualMachineDto vm, VLANNetworkDto vlan, int pollInterval, int maxWait, TimeUnit timeUnit)
NatIpDto	assignNatIPToVirtualDatacenter(NatNetworkDto natNW, VirtualDatacenterDto vdc)
VirtualMachineDto	assignPublicIpToVirtualMachine(PublicIpDto ip, PublicCloudRegionDto location, VirtualDatacenterDto vdc, VirtualMachineDto vm, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualMachineDto	attachVolume(VirtualMachineDto vm, VolumeManagementDto vol)
VirtualMachineDto	attachVolume(VirtualMachineDto vm, VolumeManagementDto vol, int pollInterval, int maxWait, TimeUnit timeUnit)
VPNTunnelStatusDto	checkTunnelStatusOfAnIPSecVPN(IPSecVPNDto vpn)
VirtualMachineDto	cloneVirtualMachine(VirtualMachineDto vm)
ActionPlanDto	createActionPlan(ActionPlanDto ap)
AvailabilitySetDto	createAvailabilitySet(PublicCloudRegionDto location, VirtualDatacenterDto vdc, String name)
FirewallPolicyDto	createFirewallPolicy(String name, String description, DeviceDto firewallDevice, com.google.common.base.Optional<VirtualDatacenterDto> optVdc, boolean isVdcDefault)
DiskManagementDto	createHardDisk(VirtualDatacenterDto vdc, DiskManagementDto disk)
HealthCheckDto	createHealthCheck(LoadBalancerDto lbd, String name, String protocol, long intervalInMs, long timeoutInMs, Integer attemps, Integer port, String path)
IPSecVPNDto	createIPSecVPN(VirtualDatacenterDto vdc, String name, String remoteEndpoint, String encryptionAlgorithm, boolean perfectForwardSecrecyEnabled, String dhGroup, String authentication, Set<String> remoteNetworks, String presharedKey, com.google.common.base.Optional<RESTLink> localEndpoint, com.google.common.base.Optional<Set<VLANNetworkDto>> localNetworks, long pollInterval, long maxWait, TimeUnit timeUnit)
LoadBalancerDto	createLoadBalancer(DeviceDto device, String name, String algorithm, List<RoutingRuleDto> routingRules, List<HealthCheckDto> healthChecks, List<LoadBalancerAddressDto> lbAddresses, List<FirewallPolicyDto> firewalls, com.google.common.base.Optional<VirtualDatacenterDto> vdc, com.google.common.base.Optional<VLANNetworkDto> network)
void	createMultipleIPsExternalNetwork(VLANNetworkDto extNetDto, String starterIP, int nIPs)
PublicIpDto	createPublicIp(PublicCloudRegionDto location)
RoutingRuleDto	createRoutingRule(LoadBalancerDto lbd, String protocolIn, String protocolOut, int portIn, int portOut, SSLCertificateDto sslCertificate)
VirtualApplianceDto	createVirtualAppliance(VirtualDatacenterDto vdc, String name)
VirtualDatacenterDto	createVirtualDatacenter(SingleResourceTransportDto location, EnterpriseDto enterprise, String name, String type, String vlanAddress, String vlanGateway, String vlanName, long pollInterval, long maxWait, TimeUnit timeUnit)
VirtualDatacenterDto	createVirtualDatacenter(SingleResourceTransportDto location, EnterpriseDto enterprise, String name, String type, VLANNetworkDto vlan, long pollInterval, long maxWait, TimeUnit timeUnit)
VirtualDatacenterDto	createVirtualDatacenter(SingleResourceTransportDto location, EnterpriseDto enterprise, String name, String type, VLANNetworkDto vlan, Optional<AddressRangesDto> addressRanges, long pollInterval, long maxWait, TimeUnit timeUnit)
VirtualMachineDto	createVirtualMachine(VirtualMachineTemplateDto template, VirtualApplianceDto vapp)
VirtualMachineDto	createVirtualMachine(VirtualMachineTemplateDto template, VirtualApplianceDto vapp, HardwareProfileDto hp)
VirtualMachineDto	createVirtualMachine(VirtualMachineTemplateDto template, VirtualApplianceDto vapp, HardwareProfileDto hp, Optional<AvailabilitySetDto> availabilitySet)
VirtualMachineDto	createVirtualMachineWithFirewall(VirtualMachineTemplateDto template, VirtualApplianceDto vapp, FirewallPolicyDto fw, HardwareProfileDto hp)
VirtualMachineDto	createVirtualMachineWithFirewallAndLabel(VirtualMachineTemplateDto template, VirtualApplianceDto vapp, FirewallPolicyDto fw, HardwareProfileDto hp, String label)
VirtualMachineDto	createVirtualMachineWithLabel(VirtualMachineTemplateDto template, VirtualApplianceDto vapp, HardwareProfileDto hp, Optional<AvailabilitySetDto> availabiltySet, String label)
VolumeManagementDto	createVolume(VirtualDatacenterDto vdc, String name, long sizeInMb, TierDto tier)
VolumeManagementDto	createVolume(VirtualDatacenterDto vdc, String name, long sizeInMb, TierDto tier, Optional<AvailabilityZoneDto> availabilityZone)
void	deleteActionPlan(ActionPlanDto ap)
void	deleteFirewallPolicies(FirewallPolicyDto firewall)
void	deleteHealthCheck(HealthCheckDto healthCheck)
void	deleteIPSecVPN(SingleResourceTransportDto vpn, long pollInterval, long maxWait, TimeUnit timeUnit)
void	deleteLoadBalancer(LoadBalancerDto lbd)
void	deleteRoutingRule(RoutingRuleDto routingRule)
void	deleteVirtualDatacenter(SingleResourceTransportDto vdc, long pollInterval, long maxWait, TimeUnit timeUnit)
VirtualApplianceDto	deploy(VirtualApplianceDto vapp, boolean forceDeploy, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualApplianceDto	deploy(VirtualApplianceDto vapp, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualMachineDto	deploy(VirtualMachineDto vm, boolean forceDeploy, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualMachineDto	deploy(VirtualMachineDto vm, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualMachineDto	detachAllExternalIPs(VirtualMachineDto vm)
VirtualMachineDto	detachAllExternalIPs(VirtualMachineDto vm, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualMachineDto	detachVolume(VirtualMachineDto vm, VolumeManagementDto vol)
VirtualMachineDto	detachVolume(VirtualMachineDto vm, VolumeManagementDto vol, int pollInterval, int maxWait, TimeUnit timeUnit)
ActionPlanDto	editActionPlan(ActionPlanDto ap)
HealthCheckDto	editHealthCheck(HealthCheckDto healthCheck)
HealthChecksDto	editHealthChecks(HealthChecksDto healthChecks)
IPSecVPNDto	editIPSecVPNDto(IPSecVPNDto vpn, long pollInterval, long maxWait, TimeUnit timeUnit)
LoadBalancerDto	editLoadBalancer(LoadBalancerDto lbd)
RoutingRuleDto	editRoutingRule(RoutingRuleDto routingRule)
RoutingRulesDto	editRoutingRules(RoutingRulesDto routingRules)
VirtualDatacenterDto	editVirtualDatacenter(VirtualDatacenterDto vdc)
VirtualMachineDto	editVirtualMachine(VirtualMachineDto vm, int pollInterval, int maxWait, TimeUnit timeUnit)
TaskDto	executeActionPlanAndGetTask(ActionPlanDto ap, int pollInterval, int maxWait, TimeUnit timeUnit)
boolean	executeActionPlanAndWait(ActionPlanDto ap, int pollInterval, int maxWait, TimeUnit timeUnit)
HealthCheckDto	getHealthCheck(LoadBalancerDto lbd, int idHealthCheck)
IPSecVPNDto	getIPSecVPN(int idVdc, int idVpn)
LoadBalancerDto	getLoadBalacer(DeviceDto device, int idLoadBalancer)
NicsDto	getNics(VirtualMachineDto vm)
VLANNetworkDto	getPrivateNetwork(VirtualDatacenterDto vdc, int idNetwork)
RoutingRuleDto	getRoutingRule(LoadBalancerDto lbd, int idRoutingRule)
TaskDto	getTask(VirtualMachineDto vm, String idTask)
VirtualApplianceDto	getVirtualAppliance(int idVdc, int idVapp)
VirtualDatacenterDto	getVirtualDatacenter(int id)
VirtualMachineDto	getVirtualMachine(VirtualApplianceDto vapp, int idVm)
VolumeManagementDto	getVolume(VirtualDatacenterDto vdc, int idVolume)
Iterable<ActionPlanDto>	listActionPlans()
Iterable<ActionPlanFlatDto>	listActionPlansFlat()
Iterable<DatacenterDto>	listAllowedDatacenters()
Iterable<DatacenterDto>	listAllowedDatacenters(AllowedDatacenterListOptions options)
Iterable<PublicCloudRegionDto>	listAllowedPublicCloudRegions()
Iterable<PublicCloudRegionDto>	listAllowedPublicCloudRegions(AllowedPublicCloudRegionListOptions options)
Iterable<AvailabilityZoneDto>	listAvailabiltyZones(VirtualDatacenterDto vdc)
Iterable<DeviceDto>	listDevices(LocationDto location)
Iterable<DeviceDto>	listDevicesInLocation(LocationDto location)
Iterable<EventDto>	listEvents()
Iterable<EventDto>	listEvents(EventListOptions options)
Iterable<ExternalIpDto>	listExternalIps(VirtualDatacenterDto vdc)
Iterable<ExternalIpDto>	listExternalIps(VirtualDatacenterDto vdc, ExternalIpListOptions options)
Iterable<FirewallPolicyDto>	listFirewallPolicies(DeviceDto device)
Iterable<FirewallPolicyDto>	listFirewallPolicies(VirtualDatacenterDto vdc)
Iterable<DiskManagementDto>	listHardDisks(VirtualMachineDto vm)
Iterable<HealthCheckDto>	listHealthChecks(LoadBalancerDto lbd)
Iterable<IPSecVPNDto>	listIPSecVPN(VirtualDatacenterDto vdc)
Iterable<LoadBalancerDto>	listLoadBalancers(DeviceDto lbd)
Iterable<LoadBalancerDto>	listLoadBalancers(VirtualDatacenterDto vdc)
Iterable<NatIpDto>	listNatIPsInVirtualDatacenter(VirtualDatacenterDto vdc)
Iterable<NatNetworkDto>	listNatNetworksInADevice(DeviceDto device)
Iterable<VMNetworkConfigurationDto>	listNetworkConfigurations(VirtualMachineDto vm)
Iterable<RoutingRuleDto>	listRoutingRules(LoadBalancerDto lbd)
Iterable<TaskDto>	listTasksInActionPlan(ActionPlanDto ap)
Iterable<TierDto>	listTiers(VirtualDatacenterDto vdc)
Iterable<VirtualApplianceDto>	listVirtualAppliances(VirtualDatacenterDto vdc)
Iterable<VirtualApplianceDto>	listVirtualAppliances(VirtualDatacenterDto vdc, VirtualApplianceListOptions options)
Iterable<VirtualDatacenterDto>	listVirtualDatacenters()
Iterable<VirtualDatacenterDto>	listVirtualDatacenters(VirtualDatacenterListOptions options)
Iterable<VirtualMachineDto>	listVirtualMachines(VirtualApplianceDto vapp)
Iterable<VirtualMachineDto>	listVirtualMachines(VirtualApplianceDto vapp, VirtualMachineListOptions options)
Iterable<VolumeManagementDto>	listVolumes(VirtualDatacenterDto vdc)
FirewallPolicyDto	makeThisFirewallPolicyDefaultForVirtualDatacenter(FirewallPolicyDto fw)
void	makeVlanDefault(VirtualDatacenterDto vdc, VLANNetworkDto vlan)
VirtualMachineDto	powerState(VirtualMachineDto vm, VirtualMachineState state, int pollInterval, int maxWait, TimeUnit timeUnit)
PublicIpDto	releasePublicIpFromVirtualDatacenter(PublicIpDto publicip, VirtualDatacenterDto vdc)
Iterable<FirewallPolicyDto>	syncFirewallPolicies(VirtualDatacenterDto vdc)
void	syncVirtualDatacenter(ApiClient api, VirtualDatacenterDto vdc, int syncVDCPollInterval, int syncVDCWaitTime, TimeUnit syncVDCTimeUnit)
VirtualApplianceDto	undeploy(VirtualApplianceDto vapp, boolean forceUndeploy, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualApplianceDto	undeploy(VirtualApplianceDto vapp, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualMachineDto	undeploy(VirtualMachineDto vm, boolean forceUndeploy, int pollInterval, int maxWait, TimeUnit timeUnit)
VirtualMachineDto	undeploy(VirtualMachineDto vm, int pollInterval, int maxWait, TimeUnit timeUnit)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

getVirtualDatacenter

public VirtualDatacenterDto getVirtualDatacenter(int id)

editVirtualDatacenter

public VirtualDatacenterDto editVirtualDatacenter(VirtualDatacenterDto vdc)

listAllowedDatacenters

public Iterable<DatacenterDto> listAllowedDatacenters()

listAllowedDatacenters

public Iterable<DatacenterDto> listAllowedDatacenters(AllowedDatacenterListOptions options)

listEvents

public Iterable<EventDto> listEvents()

listEvents

public Iterable<EventDto> listEvents(EventListOptions options)

listAllowedPublicCloudRegions

public Iterable<PublicCloudRegionDto> listAllowedPublicCloudRegions()

listAllowedPublicCloudRegions

public Iterable<PublicCloudRegionDto> listAllowedPublicCloudRegions(AllowedPublicCloudRegionListOptions options)

listAvailabiltyZones

public Iterable<AvailabilityZoneDto> listAvailabiltyZones(VirtualDatacenterDto vdc)

listVirtualDatacenters

public Iterable<VirtualDatacenterDto> listVirtualDatacenters()

listVirtualDatacenters

public Iterable<VirtualDatacenterDto> listVirtualDatacenters(VirtualDatacenterListOptions options)

listExternalIps

public Iterable<ExternalIpDto> listExternalIps(VirtualDatacenterDto vdc)

listExternalIps

public Iterable<ExternalIpDto> listExternalIps(VirtualDatacenterDto vdc,
                                               ExternalIpListOptions options)

listVirtualAppliances

public Iterable<VirtualApplianceDto> listVirtualAppliances(VirtualDatacenterDto vdc)

listVirtualAppliances

public Iterable<VirtualApplianceDto> listVirtualAppliances(VirtualDatacenterDto vdc,
                                                           VirtualApplianceListOptions options)

getVirtualAppliance

public VirtualApplianceDto getVirtualAppliance(int idVdc,
                                               int idVapp)

listVirtualMachines

public Iterable<VirtualMachineDto> listVirtualMachines(VirtualApplianceDto vapp)

listVirtualMachines

public Iterable<VirtualMachineDto> listVirtualMachines(VirtualApplianceDto vapp,
                                                       VirtualMachineListOptions options)

getPrivateNetwork

public VLANNetworkDto getPrivateNetwork(VirtualDatacenterDto vdc,
                                        int idNetwork)

listNetworkConfigurations

public Iterable<VMNetworkConfigurationDto> listNetworkConfigurations(VirtualMachineDto vm)

getVirtualMachine

public VirtualMachineDto getVirtualMachine(VirtualApplianceDto vapp,
                                           int idVm)

createVirtualDatacenter

public VirtualDatacenterDto createVirtualDatacenter(SingleResourceTransportDto location,
                                                    EnterpriseDto enterprise,
                                                    String name,
                                                    String type,
                                                    String vlanAddress,
                                                    String vlanGateway,
                                                    String vlanName,
                                                    long pollInterval,
                                                    long maxWait,
                                                    TimeUnit timeUnit)
                                             throws TimeoutException,
                                                    AsyncTaskFailedException

Throws:

TimeoutException

AsyncTaskFailedException

createVirtualDatacenter

public VirtualDatacenterDto createVirtualDatacenter(SingleResourceTransportDto location,
                                                    EnterpriseDto enterprise,
                                                    String name,
                                                    String type,
                                                    VLANNetworkDto vlan,
                                                    long pollInterval,
                                                    long maxWait,
                                                    TimeUnit timeUnit)
                                             throws TimeoutException,
                                                    AsyncTaskFailedException

Throws:

TimeoutException

AsyncTaskFailedException

createVirtualDatacenter

public VirtualDatacenterDto createVirtualDatacenter(SingleResourceTransportDto location,
                                                    EnterpriseDto enterprise,
                                                    String name,
                                                    String type,
                                                    VLANNetworkDto vlan,
                                                    Optional<AddressRangesDto> addressRanges,
                                                    long pollInterval,
                                                    long maxWait,
                                                    TimeUnit timeUnit)
                                             throws TimeoutException,
                                                    AsyncTaskFailedException

Throws:

TimeoutException

AsyncTaskFailedException

deleteVirtualDatacenter

public void deleteVirtualDatacenter(SingleResourceTransportDto vdc,
                                    long pollInterval,
                                    long maxWait,
                                    TimeUnit timeUnit)
                             throws TimeoutException,
                                    AsyncTaskFailedException

Throws:

TimeoutException

AsyncTaskFailedException

createPublicIp

public PublicIpDto createPublicIp(PublicCloudRegionDto location)

createMultipleIPsExternalNetwork

public void createMultipleIPsExternalNetwork(VLANNetworkDto extNetDto,
                                             String starterIP,
                                             int nIPs)

addPublicIpToVirtualDatacenter

public PublicIpDto addPublicIpToVirtualDatacenter(PublicIpDto publicip,
                                                  VirtualDatacenterDto vdc)

releasePublicIpFromVirtualDatacenter

public PublicIpDto releasePublicIpFromVirtualDatacenter(PublicIpDto publicip,
                                                        VirtualDatacenterDto vdc)

assignPublicIpToVirtualMachine

public VirtualMachineDto assignPublicIpToVirtualMachine(PublicIpDto ip,
                                                        PublicCloudRegionDto location,
                                                        VirtualDatacenterDto vdc,
                                                        VirtualMachineDto vm,
                                                        int pollInterval,
                                                        int maxWait,
                                                        TimeUnit timeUnit)

assignAvailabilitySetToVirtualMachine

public VirtualMachineDto assignAvailabilitySetToVirtualMachine(AvailabilitySetDto availabilitySet,
                                                               PublicCloudRegionDto location,
                                                               VirtualDatacenterDto vdc,
                                                               VirtualMachineDto vm,
                                                               int pollInterval,
                                                               int maxWait,
                                                               TimeUnit timeUnit)

createVirtualAppliance

public VirtualApplianceDto createVirtualAppliance(VirtualDatacenterDto vdc,
                                                  String name)

createVirtualMachine

public VirtualMachineDto createVirtualMachine(VirtualMachineTemplateDto template,
                                              VirtualApplianceDto vapp)

createVirtualMachineWithFirewall

public VirtualMachineDto createVirtualMachineWithFirewall(VirtualMachineTemplateDto template,
                                                          VirtualApplianceDto vapp,
                                                          FirewallPolicyDto fw,
                                                          HardwareProfileDto hp)

createVirtualMachineWithFirewallAndLabel

public VirtualMachineDto createVirtualMachineWithFirewallAndLabel(VirtualMachineTemplateDto template,
                                                                  VirtualApplianceDto vapp,
                                                                  FirewallPolicyDto fw,
                                                                  HardwareProfileDto hp,
                                                                  String label)

createVirtualMachine

public VirtualMachineDto createVirtualMachine(VirtualMachineTemplateDto template,
                                              VirtualApplianceDto vapp,
                                              HardwareProfileDto hp,
                                              Optional<AvailabilitySetDto> availabilitySet)

createVirtualMachineWithLabel

public VirtualMachineDto createVirtualMachineWithLabel(VirtualMachineTemplateDto template,
                                                       VirtualApplianceDto vapp,
                                                       HardwareProfileDto hp,
                                                       Optional<AvailabilitySetDto> availabiltySet,
                                                       String label)

createVirtualMachine

public VirtualMachineDto createVirtualMachine(VirtualMachineTemplateDto template,
                                              VirtualApplianceDto vapp,
                                              HardwareProfileDto hp)

deploy

public VirtualMachineDto deploy(VirtualMachineDto vm,
                                int pollInterval,
                                int maxWait,
                                TimeUnit timeUnit)

deploy

public VirtualMachineDto deploy(VirtualMachineDto vm,
                                boolean forceDeploy,
                                int pollInterval,
                                int maxWait,
                                TimeUnit timeUnit)

deploy

public VirtualApplianceDto deploy(VirtualApplianceDto vapp,
                                  int pollInterval,
                                  int maxWait,
                                  TimeUnit timeUnit)

deploy

public VirtualApplianceDto deploy(VirtualApplianceDto vapp,
                                  boolean forceDeploy,
                                  int pollInterval,
                                  int maxWait,
                                  TimeUnit timeUnit)

undeploy

public VirtualMachineDto undeploy(VirtualMachineDto vm,
                                  boolean forceUndeploy,
                                  int pollInterval,
                                  int maxWait,
                                  TimeUnit timeUnit)

undeploy

public VirtualMachineDto undeploy(VirtualMachineDto vm,
                                  int pollInterval,
                                  int maxWait,
                                  TimeUnit timeUnit)

undeploy

public VirtualApplianceDto undeploy(VirtualApplianceDto vapp,
                                    boolean forceUndeploy,
                                    int pollInterval,
                                    int maxWait,
                                    TimeUnit timeUnit)

undeploy

public VirtualApplianceDto undeploy(VirtualApplianceDto vapp,
                                    int pollInterval,
                                    int maxWait,
                                    TimeUnit timeUnit)

powerState

public VirtualMachineDto powerState(VirtualMachineDto vm,
                                    VirtualMachineState state,
                                    int pollInterval,
                                    int maxWait,
                                    TimeUnit timeUnit)

editVirtualMachine

public VirtualMachineDto editVirtualMachine(VirtualMachineDto vm,
                                            int pollInterval,
                                            int maxWait,
                                            TimeUnit timeUnit)

getVolume

public VolumeManagementDto getVolume(VirtualDatacenterDto vdc,
                                     int idVolume)

createVolume

public VolumeManagementDto createVolume(VirtualDatacenterDto vdc,
                                        String name,
                                        long sizeInMb,
                                        TierDto tier)

createVolume

public VolumeManagementDto createVolume(VirtualDatacenterDto vdc,
                                        String name,
                                        long sizeInMb,
                                        TierDto tier,
                                        Optional<AvailabilityZoneDto> availabilityZone)

getTask

public TaskDto getTask(VirtualMachineDto vm,
                       String idTask)

listTiers

public Iterable<TierDto> listTiers(VirtualDatacenterDto vdc)

listDevices

public Iterable<DeviceDto> listDevices(LocationDto location)

listVolumes

public Iterable<VolumeManagementDto> listVolumes(VirtualDatacenterDto vdc)

listDevicesInLocation

public Iterable<DeviceDto> listDevicesInLocation(LocationDto location)

listLoadBalancers

public Iterable<LoadBalancerDto> listLoadBalancers(VirtualDatacenterDto vdc)

listLoadBalancers

public Iterable<LoadBalancerDto> listLoadBalancers(DeviceDto lbd)

getLoadBalacer

public LoadBalancerDto getLoadBalacer(DeviceDto device,
                                      int idLoadBalancer)

deleteLoadBalancer

public void deleteLoadBalancer(LoadBalancerDto lbd)

editLoadBalancer

public LoadBalancerDto editLoadBalancer(LoadBalancerDto lbd)

createLoadBalancer

public LoadBalancerDto createLoadBalancer(DeviceDto device,
                                          String name,
                                          String algorithm,
                                          List<RoutingRuleDto> routingRules,
                                          List<HealthCheckDto> healthChecks,
                                          List<LoadBalancerAddressDto> lbAddresses,
                                          List<FirewallPolicyDto> firewalls,
                                          com.google.common.base.Optional<VirtualDatacenterDto> vdc,
                                          com.google.common.base.Optional<VLANNetworkDto> network)

createHealthCheck

public HealthCheckDto createHealthCheck(LoadBalancerDto lbd,
                                        String name,
                                        String protocol,
                                        long intervalInMs,
                                        long timeoutInMs,
                                        Integer attemps,
                                        Integer port,
                                        String path)

createRoutingRule

public RoutingRuleDto createRoutingRule(LoadBalancerDto lbd,
                                        String protocolIn,
                                        String protocolOut,
                                        int portIn,
                                        int portOut,
                                        SSLCertificateDto sslCertificate)

listRoutingRules

public Iterable<RoutingRuleDto> listRoutingRules(LoadBalancerDto lbd)

listHealthChecks

public Iterable<HealthCheckDto> listHealthChecks(LoadBalancerDto lbd)

editRoutingRules

public RoutingRulesDto editRoutingRules(RoutingRulesDto routingRules)

editHealthChecks

public HealthChecksDto editHealthChecks(HealthChecksDto healthChecks)

deleteRoutingRule

public void deleteRoutingRule(RoutingRuleDto routingRule)

deleteHealthCheck

public void deleteHealthCheck(HealthCheckDto healthCheck)

editRoutingRule

public RoutingRuleDto editRoutingRule(RoutingRuleDto routingRule)

editHealthCheck

public HealthCheckDto editHealthCheck(HealthCheckDto healthCheck)

getRoutingRule

public RoutingRuleDto getRoutingRule(LoadBalancerDto lbd,
                                     int idRoutingRule)

getHealthCheck

public HealthCheckDto getHealthCheck(LoadBalancerDto lbd,
                                     int idHealthCheck)

createFirewallPolicy

public FirewallPolicyDto createFirewallPolicy(String name,
                                              String description,
                                              DeviceDto firewallDevice,
                                              com.google.common.base.Optional<VirtualDatacenterDto> optVdc,
                                              boolean isVdcDefault)

listFirewallPolicies

public Iterable<FirewallPolicyDto> listFirewallPolicies(DeviceDto device)

listFirewallPolicies

public Iterable<FirewallPolicyDto> listFirewallPolicies(VirtualDatacenterDto vdc)

makeThisFirewallPolicyDefaultForVirtualDatacenter

public FirewallPolicyDto makeThisFirewallPolicyDefaultForVirtualDatacenter(FirewallPolicyDto fw)

deleteFirewallPolicies

public void deleteFirewallPolicies(FirewallPolicyDto firewall)

addFirewallRules

public FirewallRulesDto addFirewallRules(FirewallPolicyDto firewall,
                                         FirewallRulesDto rules)

addFirewallToVirtualMachine

public VirtualMachineDto addFirewallToVirtualMachine(FirewallPolicyDto firewall,
                                                     VirtualMachineDto vm,
                                                     int pollInterval,
                                                     int maxWait,
                                                     TimeUnit timeUnit)

getNics

public NicsDto getNics(VirtualMachineDto vm)

cloneVirtualMachine

public VirtualMachineDto cloneVirtualMachine(VirtualMachineDto vm)

createIPSecVPN

public IPSecVPNDto createIPSecVPN(VirtualDatacenterDto vdc,
                                  String name,
                                  String remoteEndpoint,
                                  String encryptionAlgorithm,
                                  boolean perfectForwardSecrecyEnabled,
                                  String dhGroup,
                                  String authentication,
                                  Set<String> remoteNetworks,
                                  String presharedKey,
                                  com.google.common.base.Optional<RESTLink> localEndpoint,
                                  com.google.common.base.Optional<Set<VLANNetworkDto>> localNetworks,
                                  long pollInterval,
                                  long maxWait,
                                  TimeUnit timeUnit)
                           throws TimeoutException,
                                  AsyncTaskFailedException

Throws:

TimeoutException

AsyncTaskFailedException

listIPSecVPN

public Iterable<IPSecVPNDto> listIPSecVPN(VirtualDatacenterDto vdc)

getIPSecVPN

public IPSecVPNDto getIPSecVPN(int idVdc,
                               int idVpn)

deleteIPSecVPN

public void deleteIPSecVPN(SingleResourceTransportDto vpn,
                           long pollInterval,
                           long maxWait,
                           TimeUnit timeUnit)
                    throws TimeoutException,
                           AsyncTaskFailedException

Throws:

TimeoutException

AsyncTaskFailedException

editIPSecVPNDto

public IPSecVPNDto editIPSecVPNDto(IPSecVPNDto vpn,
                                   long pollInterval,
                                   long maxWait,
                                   TimeUnit timeUnit)
                            throws TimeoutException,
                                   AsyncTaskFailedException

Throws:

TimeoutException

AsyncTaskFailedException

checkTunnelStatusOfAnIPSecVPN

public VPNTunnelStatusDto checkTunnelStatusOfAnIPSecVPN(IPSecVPNDto vpn)

listNatNetworksInADevice

public Iterable<NatNetworkDto> listNatNetworksInADevice(DeviceDto device)

listNatIPsInVirtualDatacenter

public Iterable<NatIpDto> listNatIPsInVirtualDatacenter(VirtualDatacenterDto vdc)

assignNatIPToVirtualDatacenter

public NatIpDto assignNatIPToVirtualDatacenter(NatNetworkDto natNW,
                                               VirtualDatacenterDto vdc)

syncFirewallPolicies

public Iterable<FirewallPolicyDto> syncFirewallPolicies(VirtualDatacenterDto vdc)

assignIpToVirtualMachine

public VirtualMachineDto assignIpToVirtualMachine(VirtualMachineDto vm,
                                                  VLANNetworkDto vlan,
                                                  int pollInterval,
                                                  int maxWait,
                                                  TimeUnit timeUnit)

syncVirtualDatacenter

public void syncVirtualDatacenter(ApiClient api,
                                  VirtualDatacenterDto vdc,
                                  int syncVDCPollInterval,
                                  int syncVDCWaitTime,
                                  TimeUnit syncVDCTimeUnit)

createHardDisk

public DiskManagementDto createHardDisk(VirtualDatacenterDto vdc,
                                        DiskManagementDto disk)

listHardDisks

public Iterable<DiskManagementDto> listHardDisks(VirtualMachineDto vm)

detachVolume

public VirtualMachineDto detachVolume(VirtualMachineDto vm,
                                      VolumeManagementDto vol)

detachVolume

public VirtualMachineDto detachVolume(VirtualMachineDto vm,
                                      VolumeManagementDto vol,
                                      int pollInterval,
                                      int maxWait,
                                      TimeUnit timeUnit)

detachAllExternalIPs

public VirtualMachineDto detachAllExternalIPs(VirtualMachineDto vm)

detachAllExternalIPs

public VirtualMachineDto detachAllExternalIPs(VirtualMachineDto vm,
                                              int pollInterval,
                                              int maxWait,
                                              TimeUnit timeUnit)

attachVolume

public VirtualMachineDto attachVolume(VirtualMachineDto vm,
                                      VolumeManagementDto vol)

attachVolume

public VirtualMachineDto attachVolume(VirtualMachineDto vm,
                                      VolumeManagementDto vol,
                                      int pollInterval,
                                      int maxWait,
                                      TimeUnit timeUnit)

createActionPlan

public ActionPlanDto createActionPlan(ActionPlanDto ap)

listActionPlans

public Iterable<ActionPlanDto> listActionPlans()

listActionPlansFlat

public Iterable<ActionPlanFlatDto> listActionPlansFlat()

editActionPlan

public ActionPlanDto editActionPlan(ActionPlanDto ap)

deleteActionPlan

public void deleteActionPlan(ActionPlanDto ap)

listTasksInActionPlan

public Iterable<TaskDto> listTasksInActionPlan(ActionPlanDto ap)

executeActionPlanAndGetTask

public TaskDto executeActionPlanAndGetTask(ActionPlanDto ap,
                                           int pollInterval,
                                           int maxWait,
                                           TimeUnit timeUnit)

executeActionPlanAndWait

public boolean executeActionPlanAndWait(ActionPlanDto ap,
                                        int pollInterval,
                                        int maxWait,
                                        TimeUnit timeUnit)

createAvailabilitySet

public AvailabilitySetDto createAvailabilitySet(PublicCloudRegionDto location,
                                                VirtualDatacenterDto vdc,
                                                String name)

makeVlanDefault

public void makeVlanDefault(VirtualDatacenterDto vdc,
                            VLANNetworkDto vlan)