LoadBalancerAsync (Oracle Cloud Infrastructure Java SDK

All Superinterfaces:

AutoCloseable

All Known Implementing Classes:

LoadBalancerAsyncClient
```
@Generated(value="OracleSDKGenerator",
           comments="API Version: 20170115")
public interface LoadBalancerAsync
extends AutoCloseable
```
API for the Load Balancing service. Use this API to manage load balancers, backend sets, and related items. For more information, see Overview of Load Balancing.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`Future<ChangeLoadBalancerCompartmentResponse>`	`changeLoadBalancerCompartment(ChangeLoadBalancerCompartmentRequest request, AsyncHandler<ChangeLoadBalancerCompartmentRequest,ChangeLoadBalancerCompartmentResponse> handler)` Moves a load balancer into a different compartment within the same tenancy.
`Future<CreateBackendResponse>`	`createBackend(CreateBackendRequest request, AsyncHandler<CreateBackendRequest,CreateBackendResponse> handler)` Adds a backend server to a backend set.
`Future<CreateBackendSetResponse>`	`createBackendSet(CreateBackendSetRequest request, AsyncHandler<CreateBackendSetRequest,CreateBackendSetResponse> handler)` Adds a backend set to a load balancer.
`Future<CreateCertificateResponse>`	`createCertificate(CreateCertificateRequest request, AsyncHandler<CreateCertificateRequest,CreateCertificateResponse> handler)` Creates an asynchronous request to add an SSL certificate bundle.
`Future<CreateHostnameResponse>`	`createHostname(CreateHostnameRequest request, AsyncHandler<CreateHostnameRequest,CreateHostnameResponse> handler)` Adds a hostname resource to the specified load balancer.
`Future<CreateListenerResponse>`	`createListener(CreateListenerRequest request, AsyncHandler<CreateListenerRequest,CreateListenerResponse> handler)` Adds a listener to a load balancer.
`Future<CreateLoadBalancerResponse>`	`createLoadBalancer(CreateLoadBalancerRequest request, AsyncHandler<CreateLoadBalancerRequest,CreateLoadBalancerResponse> handler)` Creates a new load balancer in the specified compartment.
`Future<CreatePathRouteSetResponse>`	`createPathRouteSet(CreatePathRouteSetRequest request, AsyncHandler<CreatePathRouteSetRequest,CreatePathRouteSetResponse> handler)` Adds a path route set to a load balancer.
`Future<CreateRoutingPolicyResponse>`	`createRoutingPolicy(CreateRoutingPolicyRequest request, AsyncHandler<CreateRoutingPolicyRequest,CreateRoutingPolicyResponse> handler)` Adds a routing policy to a load balancer.
`Future<CreateRuleSetResponse>`	`createRuleSet(CreateRuleSetRequest request, AsyncHandler<CreateRuleSetRequest,CreateRuleSetResponse> handler)` Creates a new rule set associated with the specified load balancer.
`Future<CreateSSLCipherSuiteResponse>`	`createSSLCipherSuite(CreateSSLCipherSuiteRequest request, AsyncHandler<CreateSSLCipherSuiteRequest,CreateSSLCipherSuiteResponse> handler)` Creates a custom SSL cipher suite.
`Future<DeleteBackendResponse>`	`deleteBackend(DeleteBackendRequest request, AsyncHandler<DeleteBackendRequest,DeleteBackendResponse> handler)` Removes a backend server from a given load balancer and backend set.
`Future<DeleteBackendSetResponse>`	`deleteBackendSet(DeleteBackendSetRequest request, AsyncHandler<DeleteBackendSetRequest,DeleteBackendSetResponse> handler)` Deletes the specified backend set.
`Future<DeleteCertificateResponse>`	`deleteCertificate(DeleteCertificateRequest request, AsyncHandler<DeleteCertificateRequest,DeleteCertificateResponse> handler)` Deletes an SSL certificate bundle from a load balancer.
`Future<DeleteHostnameResponse>`	`deleteHostname(DeleteHostnameRequest request, AsyncHandler<DeleteHostnameRequest,DeleteHostnameResponse> handler)` Deletes a hostname resource from the specified load balancer.
`Future<DeleteListenerResponse>`	`deleteListener(DeleteListenerRequest request, AsyncHandler<DeleteListenerRequest,DeleteListenerResponse> handler)` Deletes a listener from a load balancer.
`Future<DeleteLoadBalancerResponse>`	`deleteLoadBalancer(DeleteLoadBalancerRequest request, AsyncHandler<DeleteLoadBalancerRequest,DeleteLoadBalancerResponse> handler)` Stops a load balancer and removes it from service.
`Future<DeletePathRouteSetResponse>`	`deletePathRouteSet(DeletePathRouteSetRequest request, AsyncHandler<DeletePathRouteSetRequest,DeletePathRouteSetResponse> handler)` Deletes a path route set from the specified load balancer.
`Future<DeleteRoutingPolicyResponse>`	`deleteRoutingPolicy(DeleteRoutingPolicyRequest request, AsyncHandler<DeleteRoutingPolicyRequest,DeleteRoutingPolicyResponse> handler)` Deletes a routing policy from the specified load balancer.
`Future<DeleteRuleSetResponse>`	`deleteRuleSet(DeleteRuleSetRequest request, AsyncHandler<DeleteRuleSetRequest,DeleteRuleSetResponse> handler)` Deletes a rule set from the specified load balancer.
`Future<DeleteSSLCipherSuiteResponse>`	`deleteSSLCipherSuite(DeleteSSLCipherSuiteRequest request, AsyncHandler<DeleteSSLCipherSuiteRequest,DeleteSSLCipherSuiteResponse> handler)` Deletes an SSL cipher suite from a load balancer.
`Future<GetBackendResponse>`	`getBackend(GetBackendRequest request, AsyncHandler<GetBackendRequest,GetBackendResponse> handler)` Gets the specified backend server’s configuration information.
`Future<GetBackendHealthResponse>`	`getBackendHealth(GetBackendHealthRequest request, AsyncHandler<GetBackendHealthRequest,GetBackendHealthResponse> handler)` Gets the current health status of the specified backend server.
`Future<GetBackendSetResponse>`	`getBackendSet(GetBackendSetRequest request, AsyncHandler<GetBackendSetRequest,GetBackendSetResponse> handler)` Gets the specified backend set’s configuration information.
`Future<GetBackendSetHealthResponse>`	`getBackendSetHealth(GetBackendSetHealthRequest request, AsyncHandler<GetBackendSetHealthRequest,GetBackendSetHealthResponse> handler)` Gets the health status for the specified backend set.
`String`	`getEndpoint()` Gets the set endpoint for REST call (ex, https://www.example.com)
`Future<GetHealthCheckerResponse>`	`getHealthChecker(GetHealthCheckerRequest request, AsyncHandler<GetHealthCheckerRequest,GetHealthCheckerResponse> handler)` Gets the health check policy information for a given load balancer and backend set.
`Future<GetHostnameResponse>`	`getHostname(GetHostnameRequest request, AsyncHandler<GetHostnameRequest,GetHostnameResponse> handler)` Gets the specified hostname resource’s configuration information.
`Future<GetLoadBalancerResponse>`	`getLoadBalancer(GetLoadBalancerRequest request, AsyncHandler<GetLoadBalancerRequest,GetLoadBalancerResponse> handler)` Gets the specified load balancer’s configuration information.
`Future<GetLoadBalancerHealthResponse>`	`getLoadBalancerHealth(GetLoadBalancerHealthRequest request, AsyncHandler<GetLoadBalancerHealthRequest,GetLoadBalancerHealthResponse> handler)` Gets the health status for the specified load balancer.
`Future<GetPathRouteSetResponse>`	`getPathRouteSet(GetPathRouteSetRequest request, AsyncHandler<GetPathRouteSetRequest,GetPathRouteSetResponse> handler)` Gets the specified path route set’s configuration information.
`Future<GetRoutingPolicyResponse>`	`getRoutingPolicy(GetRoutingPolicyRequest request, AsyncHandler<GetRoutingPolicyRequest,GetRoutingPolicyResponse> handler)` Gets the specified routing policy.
`Future<GetRuleSetResponse>`	`getRuleSet(GetRuleSetRequest request, AsyncHandler<GetRuleSetRequest,GetRuleSetResponse> handler)` Gets the specified set of rules.
`Future<GetSSLCipherSuiteResponse>`	`getSSLCipherSuite(GetSSLCipherSuiteRequest request, AsyncHandler<GetSSLCipherSuiteRequest,GetSSLCipherSuiteResponse> handler)` Gets the specified SSL cipher suite’s configuration information.
`Future<GetWorkRequestResponse>`	`getWorkRequest(GetWorkRequestRequest request, AsyncHandler<GetWorkRequestRequest,GetWorkRequestResponse> handler)` Gets the details of a work request.
`Future<ListBackendsResponse>`	`listBackends(ListBackendsRequest request, AsyncHandler<ListBackendsRequest,ListBackendsResponse> handler)` Lists the backend servers for a given load balancer and backend set.
`Future<ListBackendSetsResponse>`	`listBackendSets(ListBackendSetsRequest request, AsyncHandler<ListBackendSetsRequest,ListBackendSetsResponse> handler)` Lists all backend sets associated with a given load balancer.
`Future<ListCertificatesResponse>`	`listCertificates(ListCertificatesRequest request, AsyncHandler<ListCertificatesRequest,ListCertificatesResponse> handler)` Lists all SSL certificates bundles associated with a given load balancer.
`Future<ListHostnamesResponse>`	`listHostnames(ListHostnamesRequest request, AsyncHandler<ListHostnamesRequest,ListHostnamesResponse> handler)` Lists all hostname resources associated with the specified load balancer.
`Future<ListListenerRulesResponse>`	`listListenerRules(ListListenerRulesRequest request, AsyncHandler<ListListenerRulesRequest,ListListenerRulesResponse> handler)` Lists all of the rules from all of the rule sets associated with the specified listener.
`Future<ListLoadBalancerHealthsResponse>`	`listLoadBalancerHealths(ListLoadBalancerHealthsRequest request, AsyncHandler<ListLoadBalancerHealthsRequest,ListLoadBalancerHealthsResponse> handler)` Lists the summary health statuses for all load balancers in the specified compartment.
`Future<ListLoadBalancersResponse>`	`listLoadBalancers(ListLoadBalancersRequest request, AsyncHandler<ListLoadBalancersRequest,ListLoadBalancersResponse> handler)` Lists all load balancers in the specified compartment.
`Future<ListPathRouteSetsResponse>`	`listPathRouteSets(ListPathRouteSetsRequest request, AsyncHandler<ListPathRouteSetsRequest,ListPathRouteSetsResponse> handler)` Lists all path route sets associated with the specified load balancer.
`Future<ListPoliciesResponse>`	`listPolicies(ListPoliciesRequest request, AsyncHandler<ListPoliciesRequest,ListPoliciesResponse> handler)` Lists the available load balancer policies.
`Future<ListProtocolsResponse>`	`listProtocols(ListProtocolsRequest request, AsyncHandler<ListProtocolsRequest,ListProtocolsResponse> handler)` Lists all supported traffic protocols.
`Future<ListRoutingPoliciesResponse>`	`listRoutingPolicies(ListRoutingPoliciesRequest request, AsyncHandler<ListRoutingPoliciesRequest,ListRoutingPoliciesResponse> handler)` Lists all routing policies associated with the specified load balancer.
`Future<ListRuleSetsResponse>`	`listRuleSets(ListRuleSetsRequest request, AsyncHandler<ListRuleSetsRequest,ListRuleSetsResponse> handler)` Lists all rule sets associated with the specified load balancer.
`Future<ListShapesResponse>`	`listShapes(ListShapesRequest request, AsyncHandler<ListShapesRequest,ListShapesResponse> handler)` Lists the valid load balancer shapes.
`Future<ListSSLCipherSuitesResponse>`	`listSSLCipherSuites(ListSSLCipherSuitesRequest request, AsyncHandler<ListSSLCipherSuitesRequest,ListSSLCipherSuitesResponse> handler)` Lists all SSL cipher suites associated with the specified load balancer.
`Future<ListWorkRequestsResponse>`	`listWorkRequests(ListWorkRequestsRequest request, AsyncHandler<ListWorkRequestsRequest,ListWorkRequestsResponse> handler)` Lists the work requests for a given load balancer.
`void`	`refreshClient()` Rebuilds the client from scratch.
`void`	`setEndpoint(String endpoint)` Sets the endpoint to call (ex, https://www.example.com).
`void`	`setRegion(Region region)` Sets the region to call (ex, Region.US_PHOENIX_1).
`void`	`setRegion(String regionId)` Sets the region to call (ex, ‘us-phoenix-1’).
`Future<UpdateBackendResponse>`	`updateBackend(UpdateBackendRequest request, AsyncHandler<UpdateBackendRequest,UpdateBackendResponse> handler)` Updates the configuration of a backend server within the specified backend set.
`Future<UpdateBackendSetResponse>`	`updateBackendSet(UpdateBackendSetRequest request, AsyncHandler<UpdateBackendSetRequest,UpdateBackendSetResponse> handler)` Updates a backend set.
`Future<UpdateHealthCheckerResponse>`	`updateHealthChecker(UpdateHealthCheckerRequest request, AsyncHandler<UpdateHealthCheckerRequest,UpdateHealthCheckerResponse> handler)` Updates the health check policy for a given load balancer and backend set.
`Future<UpdateHostnameResponse>`	`updateHostname(UpdateHostnameRequest request, AsyncHandler<UpdateHostnameRequest,UpdateHostnameResponse> handler)` Overwrites an existing hostname resource on the specified load balancer.
`Future<UpdateListenerResponse>`	`updateListener(UpdateListenerRequest request, AsyncHandler<UpdateListenerRequest,UpdateListenerResponse> handler)` Updates a listener for a given load balancer.
`Future<UpdateLoadBalancerResponse>`	`updateLoadBalancer(UpdateLoadBalancerRequest request, AsyncHandler<UpdateLoadBalancerRequest,UpdateLoadBalancerResponse> handler)` Updates a load balancer’s configuration.
`Future<UpdateLoadBalancerShapeResponse>`	`updateLoadBalancerShape(UpdateLoadBalancerShapeRequest request, AsyncHandler<UpdateLoadBalancerShapeRequest,UpdateLoadBalancerShapeResponse> handler)` Update the shape of a load balancer.
`Future<UpdateNetworkSecurityGroupsResponse>`	`updateNetworkSecurityGroups(UpdateNetworkSecurityGroupsRequest request, AsyncHandler<UpdateNetworkSecurityGroupsRequest,UpdateNetworkSecurityGroupsResponse> handler)` Updates the network security groups associated with the specified load balancer.
`Future<UpdatePathRouteSetResponse>`	`updatePathRouteSet(UpdatePathRouteSetRequest request, AsyncHandler<UpdatePathRouteSetRequest,UpdatePathRouteSetResponse> handler)` Overwrites an existing path route set on the specified load balancer.
`Future<UpdateRoutingPolicyResponse>`	`updateRoutingPolicy(UpdateRoutingPolicyRequest request, AsyncHandler<UpdateRoutingPolicyRequest,UpdateRoutingPolicyResponse> handler)` Overwrites an existing routing policy on the specified load balancer.
`Future<UpdateRuleSetResponse>`	`updateRuleSet(UpdateRuleSetRequest request, AsyncHandler<UpdateRuleSetRequest,UpdateRuleSetResponse> handler)` Overwrites an existing set of rules on the specified load balancer.
`Future<UpdateSSLCipherSuiteResponse>`	`updateSSLCipherSuite(UpdateSSLCipherSuiteRequest request, AsyncHandler<UpdateSSLCipherSuiteRequest,UpdateSSLCipherSuiteResponse> handler)` Updates an existing SSL cipher suite for the specified load balancer.
`void`	`useRealmSpecificEndpointTemplate(boolean realmSpecificEndpointTemplateEnabled)` Determines whether realm specific endpoint should be used or not.

Methods inherited from interface java.lang.AutoCloseable
close

- Method Detail
  - refreshClient
```
void refreshClient()
```
    Rebuilds the client from scratch. Useful to refresh certificates.
  - setEndpoint
```
void setEndpoint(String endpoint)
```
    Sets the endpoint to call (ex, https://www.example.com).
    
    Parameters:
    
    endpoint - The endpoint of the serice.
  - getEndpoint
```
String getEndpoint()
```
    Gets the set endpoint for REST call (ex, https://www.example.com)
  - setRegion
```
void setRegion(Region region)
```
    Sets the region to call (ex, Region.US_PHOENIX_1).
    
    Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.
    
    Parameters:
    
    region - The region of the service.
  - setRegion
```
void setRegion(String regionId)
```
    Sets the region to call (ex, ‘us-phoenix-1’).
    
    Note, this will first try to map the region ID to a known Region and call setRegion.
    If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.
    
    Parameters:
    
    regionId - The public region ID.
  - useRealmSpecificEndpointTemplate
```
void useRealmSpecificEndpointTemplate(boolean realmSpecificEndpointTemplateEnabled)
```
    Determines whether realm specific endpoint should be used or not. Set realmSpecificEndpointTemplateEnabled to “true” if the user wants to enable use of realm specific endpoint template, otherwise set it to “false”
    
    Parameters:
    
    realmSpecificEndpointTemplateEnabled - flag to enable the use of realm specific endpoint template
  - changeLoadBalancerCompartment
```
Future<ChangeLoadBalancerCompartmentResponse> changeLoadBalancerCompartment(ChangeLoadBalancerCompartmentRequest request,
                                                                            AsyncHandler<ChangeLoadBalancerCompartmentRequest,ChangeLoadBalancerCompartmentResponse> handler)
```
    Moves a load balancer into a different compartment within the same tenancy. For information about moving resources between compartments, see Moving Resources to a Different Compartment.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createBackend
```
Future<CreateBackendResponse> createBackend(CreateBackendRequest request,
                                            AsyncHandler<CreateBackendRequest,CreateBackendResponse> handler)
```
    Adds a backend server to a backend set.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createBackendSet
```
Future<CreateBackendSetResponse> createBackendSet(CreateBackendSetRequest request,
                                                  AsyncHandler<CreateBackendSetRequest,CreateBackendSetResponse> handler)
```
    Adds a backend set to a load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createCertificate
```
Future<CreateCertificateResponse> createCertificate(CreateCertificateRequest request,
                                                    AsyncHandler<CreateCertificateRequest,CreateCertificateResponse> handler)
```
    Creates an asynchronous request to add an SSL certificate bundle.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createHostname
```
Future<CreateHostnameResponse> createHostname(CreateHostnameRequest request,
                                              AsyncHandler<CreateHostnameRequest,CreateHostnameResponse> handler)
```
    Adds a hostname resource to the specified load balancer. For more information, see Managing Request Routing.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createListener
```
Future<CreateListenerResponse> createListener(CreateListenerRequest request,
                                              AsyncHandler<CreateListenerRequest,CreateListenerResponse> handler)
```
    Adds a listener to a load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createLoadBalancer
```
Future<CreateLoadBalancerResponse> createLoadBalancer(CreateLoadBalancerRequest request,
                                                      AsyncHandler<CreateLoadBalancerRequest,CreateLoadBalancerResponse> handler)
```
    Creates a new load balancer in the specified compartment. For general information about load balancers, see Overview of the Load Balancing Service.
    
    For the purposes of access control, you must provide the OCID of the compartment where you want the load balancer to reside. Notice that the load balancer doesn't have to be in the same compartment as the VCN or backend set. If you're not sure which compartment to use, put the load balancer in the same compartment as the VCN. For information about access control and compartments, see [Overview of the IAM Service](https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm).
    You must specify a display name for the load balancer. It does not have to be unique, and you can change it.
    For information about Availability Domains, see [Regions and Availability Domains](https://docs.cloud.oracle.com/Content/General/Concepts/regions.htm). To get a list of Availability Domains, use the `ListAvailabilityDomains` operation in the Identity and Access Management Service API.
    All Oracle Cloud Infrastructure resources, including load balancers, get an Oracle-assigned, unique ID called an Oracle Cloud Identifier (OCID). When you create a resource, you can find its OCID in the response. You can also retrieve a resource's OCID by using a List API operation on that resource type, or by viewing the resource in the Console. Fore more information, see [Resource Identifiers](https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm).
    After you send your request, the new object's state will temporarily be PROVISIONING. Before using the object, first make sure its state has changed to RUNNING.
    When you create a load balancer, the system assigns an IP address. To get the IP address, use the getLoadBalancer operation.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createPathRouteSet
```
Future<CreatePathRouteSetResponse> createPathRouteSet(CreatePathRouteSetRequest request,
                                                      AsyncHandler<CreatePathRouteSetRequest,CreatePathRouteSetResponse> handler)
```
    Adds a path route set to a load balancer. For more information, see Managing Request Routing.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createRoutingPolicy
```
Future<CreateRoutingPolicyResponse> createRoutingPolicy(CreateRoutingPolicyRequest request,
                                                        AsyncHandler<CreateRoutingPolicyRequest,CreateRoutingPolicyResponse> handler)
```
    Adds a routing policy to a load balancer. For more information, see Managing Request Routing.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createRuleSet
```
Future<CreateRuleSetResponse> createRuleSet(CreateRuleSetRequest request,
                                            AsyncHandler<CreateRuleSetRequest,CreateRuleSetResponse> handler)
```
    Creates a new rule set associated with the specified load balancer. For more information, see Managing Rule Sets.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createSSLCipherSuite
```
Future<CreateSSLCipherSuiteResponse> createSSLCipherSuite(CreateSSLCipherSuiteRequest request,
                                                          AsyncHandler<CreateSSLCipherSuiteRequest,CreateSSLCipherSuiteResponse> handler)
```
    Creates a custom SSL cipher suite.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteBackend
```
Future<DeleteBackendResponse> deleteBackend(DeleteBackendRequest request,
                                            AsyncHandler<DeleteBackendRequest,DeleteBackendResponse> handler)
```
    Removes a backend server from a given load balancer and backend set.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteBackendSet
```
Future<DeleteBackendSetResponse> deleteBackendSet(DeleteBackendSetRequest request,
                                                  AsyncHandler<DeleteBackendSetRequest,DeleteBackendSetResponse> handler)
```
    Deletes the specified backend set. Note that deleting a backend set removes its backend servers from the load balancer.
    
    Before you can delete a backend set, you must remove it from any active listeners.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteCertificate
```
Future<DeleteCertificateResponse> deleteCertificate(DeleteCertificateRequest request,
                                                    AsyncHandler<DeleteCertificateRequest,DeleteCertificateResponse> handler)
```
    Deletes an SSL certificate bundle from a load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteHostname
```
Future<DeleteHostnameResponse> deleteHostname(DeleteHostnameRequest request,
                                              AsyncHandler<DeleteHostnameRequest,DeleteHostnameResponse> handler)
```
    Deletes a hostname resource from the specified load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteListener
```
Future<DeleteListenerResponse> deleteListener(DeleteListenerRequest request,
                                              AsyncHandler<DeleteListenerRequest,DeleteListenerResponse> handler)
```
    Deletes a listener from a load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteLoadBalancer
```
Future<DeleteLoadBalancerResponse> deleteLoadBalancer(DeleteLoadBalancerRequest request,
                                                      AsyncHandler<DeleteLoadBalancerRequest,DeleteLoadBalancerResponse> handler)
```
    Stops a load balancer and removes it from service.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deletePathRouteSet
```
Future<DeletePathRouteSetResponse> deletePathRouteSet(DeletePathRouteSetRequest request,
                                                      AsyncHandler<DeletePathRouteSetRequest,DeletePathRouteSetResponse> handler)
```
    Deletes a path route set from the specified load balancer.
    
    To delete a path route rule from a path route set, use the updatePathRouteSet operation.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteRoutingPolicy
```
Future<DeleteRoutingPolicyResponse> deleteRoutingPolicy(DeleteRoutingPolicyRequest request,
                                                        AsyncHandler<DeleteRoutingPolicyRequest,DeleteRoutingPolicyResponse> handler)
```
    Deletes a routing policy from the specified load balancer.
    
    To delete a routing rule from a routing policy, use the updateRoutingPolicy operation.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteRuleSet
```
Future<DeleteRuleSetResponse> deleteRuleSet(DeleteRuleSetRequest request,
                                            AsyncHandler<DeleteRuleSetRequest,DeleteRuleSetResponse> handler)
```
    Deletes a rule set from the specified load balancer.
    
    To delete a rule from a rule set, use the updateRuleSet operation.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteSSLCipherSuite
```
Future<DeleteSSLCipherSuiteResponse> deleteSSLCipherSuite(DeleteSSLCipherSuiteRequest request,
                                                          AsyncHandler<DeleteSSLCipherSuiteRequest,DeleteSSLCipherSuiteResponse> handler)
```
    Deletes an SSL cipher suite from a load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackend
```
Future<GetBackendResponse> getBackend(GetBackendRequest request,
                                      AsyncHandler<GetBackendRequest,GetBackendResponse> handler)
```
    Gets the specified backend server’s configuration information.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackendHealth
```
Future<GetBackendHealthResponse> getBackendHealth(GetBackendHealthRequest request,
                                                  AsyncHandler<GetBackendHealthRequest,GetBackendHealthResponse> handler)
```
    Gets the current health status of the specified backend server.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackendSet
```
Future<GetBackendSetResponse> getBackendSet(GetBackendSetRequest request,
                                            AsyncHandler<GetBackendSetRequest,GetBackendSetResponse> handler)
```
    Gets the specified backend set’s configuration information.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackendSetHealth
```
Future<GetBackendSetHealthResponse> getBackendSetHealth(GetBackendSetHealthRequest request,
                                                        AsyncHandler<GetBackendSetHealthRequest,GetBackendSetHealthResponse> handler)
```
    Gets the health status for the specified backend set.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getHealthChecker
```
Future<GetHealthCheckerResponse> getHealthChecker(GetHealthCheckerRequest request,
                                                  AsyncHandler<GetHealthCheckerRequest,GetHealthCheckerResponse> handler)
```
    Gets the health check policy information for a given load balancer and backend set.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getHostname
```
Future<GetHostnameResponse> getHostname(GetHostnameRequest request,
                                        AsyncHandler<GetHostnameRequest,GetHostnameResponse> handler)
```
    Gets the specified hostname resource’s configuration information.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getLoadBalancer
```
Future<GetLoadBalancerResponse> getLoadBalancer(GetLoadBalancerRequest request,
                                                AsyncHandler<GetLoadBalancerRequest,GetLoadBalancerResponse> handler)
```
    Gets the specified load balancer’s configuration information.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getLoadBalancerHealth
```
Future<GetLoadBalancerHealthResponse> getLoadBalancerHealth(GetLoadBalancerHealthRequest request,
                                                            AsyncHandler<GetLoadBalancerHealthRequest,GetLoadBalancerHealthResponse> handler)
```
    Gets the health status for the specified load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getPathRouteSet
```
Future<GetPathRouteSetResponse> getPathRouteSet(GetPathRouteSetRequest request,
                                                AsyncHandler<GetPathRouteSetRequest,GetPathRouteSetResponse> handler)
```
    Gets the specified path route set’s configuration information.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getRoutingPolicy
```
Future<GetRoutingPolicyResponse> getRoutingPolicy(GetRoutingPolicyRequest request,
                                                  AsyncHandler<GetRoutingPolicyRequest,GetRoutingPolicyResponse> handler)
```
    Gets the specified routing policy.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getRuleSet
```
Future<GetRuleSetResponse> getRuleSet(GetRuleSetRequest request,
                                      AsyncHandler<GetRuleSetRequest,GetRuleSetResponse> handler)
```
    Gets the specified set of rules.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getSSLCipherSuite
```
Future<GetSSLCipherSuiteResponse> getSSLCipherSuite(GetSSLCipherSuiteRequest request,
                                                    AsyncHandler<GetSSLCipherSuiteRequest,GetSSLCipherSuiteResponse> handler)
```
    Gets the specified SSL cipher suite’s configuration information.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getWorkRequest
```
Future<GetWorkRequestResponse> getWorkRequest(GetWorkRequestRequest request,
                                              AsyncHandler<GetWorkRequestRequest,GetWorkRequestResponse> handler)
```
    Gets the details of a work request.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listBackendSets
```
Future<ListBackendSetsResponse> listBackendSets(ListBackendSetsRequest request,
                                                AsyncHandler<ListBackendSetsRequest,ListBackendSetsResponse> handler)
```
    Lists all backend sets associated with a given load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listBackends
```
Future<ListBackendsResponse> listBackends(ListBackendsRequest request,
                                          AsyncHandler<ListBackendsRequest,ListBackendsResponse> handler)
```
    Lists the backend servers for a given load balancer and backend set.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listCertificates
```
Future<ListCertificatesResponse> listCertificates(ListCertificatesRequest request,
                                                  AsyncHandler<ListCertificatesRequest,ListCertificatesResponse> handler)
```
    Lists all SSL certificates bundles associated with a given load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listHostnames
```
Future<ListHostnamesResponse> listHostnames(ListHostnamesRequest request,
                                            AsyncHandler<ListHostnamesRequest,ListHostnamesResponse> handler)
```
    Lists all hostname resources associated with the specified load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listListenerRules
```
Future<ListListenerRulesResponse> listListenerRules(ListListenerRulesRequest request,
                                                    AsyncHandler<ListListenerRulesRequest,ListListenerRulesResponse> handler)
```
    Lists all of the rules from all of the rule sets associated with the specified listener. The response organizes the rules in the following order:
    
    Access control rules * Allow method rules * Request header rules * Response header rules
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listLoadBalancerHealths
```
Future<ListLoadBalancerHealthsResponse> listLoadBalancerHealths(ListLoadBalancerHealthsRequest request,
                                                                AsyncHandler<ListLoadBalancerHealthsRequest,ListLoadBalancerHealthsResponse> handler)
```
    Lists the summary health statuses for all load balancers in the specified compartment.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listLoadBalancers
```
Future<ListLoadBalancersResponse> listLoadBalancers(ListLoadBalancersRequest request,
                                                    AsyncHandler<ListLoadBalancersRequest,ListLoadBalancersResponse> handler)
```
    Lists all load balancers in the specified compartment.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listPathRouteSets
```
Future<ListPathRouteSetsResponse> listPathRouteSets(ListPathRouteSetsRequest request,
                                                    AsyncHandler<ListPathRouteSetsRequest,ListPathRouteSetsResponse> handler)
```
    Lists all path route sets associated with the specified load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listPolicies
```
Future<ListPoliciesResponse> listPolicies(ListPoliciesRequest request,
                                          AsyncHandler<ListPoliciesRequest,ListPoliciesResponse> handler)
```
    Lists the available load balancer policies.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listProtocols
```
Future<ListProtocolsResponse> listProtocols(ListProtocolsRequest request,
                                            AsyncHandler<ListProtocolsRequest,ListProtocolsResponse> handler)
```
    Lists all supported traffic protocols.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listRoutingPolicies
```
Future<ListRoutingPoliciesResponse> listRoutingPolicies(ListRoutingPoliciesRequest request,
                                                        AsyncHandler<ListRoutingPoliciesRequest,ListRoutingPoliciesResponse> handler)
```
    Lists all routing policies associated with the specified load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listRuleSets
```
Future<ListRuleSetsResponse> listRuleSets(ListRuleSetsRequest request,
                                          AsyncHandler<ListRuleSetsRequest,ListRuleSetsResponse> handler)
```
    Lists all rule sets associated with the specified load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listSSLCipherSuites
```
Future<ListSSLCipherSuitesResponse> listSSLCipherSuites(ListSSLCipherSuitesRequest request,
                                                        AsyncHandler<ListSSLCipherSuitesRequest,ListSSLCipherSuitesResponse> handler)
```
    Lists all SSL cipher suites associated with the specified load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listShapes
```
Future<ListShapesResponse> listShapes(ListShapesRequest request,
                                      AsyncHandler<ListShapesRequest,ListShapesResponse> handler)
```
    Lists the valid load balancer shapes.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listWorkRequests
```
Future<ListWorkRequestsResponse> listWorkRequests(ListWorkRequestsRequest request,
                                                  AsyncHandler<ListWorkRequestsRequest,ListWorkRequestsResponse> handler)
```
    Lists the work requests for a given load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateBackend
```
Future<UpdateBackendResponse> updateBackend(UpdateBackendRequest request,
                                            AsyncHandler<UpdateBackendRequest,UpdateBackendResponse> handler)
```
    Updates the configuration of a backend server within the specified backend set.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateBackendSet
```
Future<UpdateBackendSetResponse> updateBackendSet(UpdateBackendSetRequest request,
                                                  AsyncHandler<UpdateBackendSetRequest,UpdateBackendSetResponse> handler)
```
    Updates a backend set.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateHealthChecker
```
Future<UpdateHealthCheckerResponse> updateHealthChecker(UpdateHealthCheckerRequest request,
                                                        AsyncHandler<UpdateHealthCheckerRequest,UpdateHealthCheckerResponse> handler)
```
    Updates the health check policy for a given load balancer and backend set.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateHostname
```
Future<UpdateHostnameResponse> updateHostname(UpdateHostnameRequest request,
                                              AsyncHandler<UpdateHostnameRequest,UpdateHostnameResponse> handler)
```
    Overwrites an existing hostname resource on the specified load balancer. Use this operation to change a virtual hostname.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateListener
```
Future<UpdateListenerResponse> updateListener(UpdateListenerRequest request,
                                              AsyncHandler<UpdateListenerRequest,UpdateListenerResponse> handler)
```
    Updates a listener for a given load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateLoadBalancer
```
Future<UpdateLoadBalancerResponse> updateLoadBalancer(UpdateLoadBalancerRequest request,
                                                      AsyncHandler<UpdateLoadBalancerRequest,UpdateLoadBalancerResponse> handler)
```
    Updates a load balancer’s configuration.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateLoadBalancerShape
```
Future<UpdateLoadBalancerShapeResponse> updateLoadBalancerShape(UpdateLoadBalancerShapeRequest request,
                                                                AsyncHandler<UpdateLoadBalancerShapeRequest,UpdateLoadBalancerShapeResponse> handler)
```
    Update the shape of a load balancer. The new shape can be larger or smaller compared to existing shape of the LB. The service will try to perform this operation in the least disruptive way to existing connections, but there is a possibility that they might be lost during the LB resizing process. The new shape becomes effective as soon as the related work request completes successfully, i.e. when reshaping to a larger shape, the LB will start accepting larger bandwidth and when reshaping to a smaller one, the LB will be accepting smaller bandwidth.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateNetworkSecurityGroups
```
Future<UpdateNetworkSecurityGroupsResponse> updateNetworkSecurityGroups(UpdateNetworkSecurityGroupsRequest request,
                                                                        AsyncHandler<UpdateNetworkSecurityGroupsRequest,UpdateNetworkSecurityGroupsResponse> handler)
```
    Updates the network security groups associated with the specified load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updatePathRouteSet
```
Future<UpdatePathRouteSetResponse> updatePathRouteSet(UpdatePathRouteSetRequest request,
                                                      AsyncHandler<UpdatePathRouteSetRequest,UpdatePathRouteSetResponse> handler)
```
    Overwrites an existing path route set on the specified load balancer. Use this operation to add, delete, or alter path route rules in a path route set.
    
    To add a new path route rule to a path route set, the `pathRoutes` in the updatePathRouteSetDetails object must include both the new path route rule to add and the existing path route rules to retain.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateRoutingPolicy
```
Future<UpdateRoutingPolicyResponse> updateRoutingPolicy(UpdateRoutingPolicyRequest request,
                                                        AsyncHandler<UpdateRoutingPolicyRequest,UpdateRoutingPolicyResponse> handler)
```
    Overwrites an existing routing policy on the specified load balancer. Use this operation to add, delete, or alter routing policy rules in a routing policy.
    
    To add a new routing rule to a routing policy, the body must include both the new routing rule to add and the existing rules to retain.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateRuleSet
```
Future<UpdateRuleSetResponse> updateRuleSet(UpdateRuleSetRequest request,
                                            AsyncHandler<UpdateRuleSetRequest,UpdateRuleSetResponse> handler)
```
    Overwrites an existing set of rules on the specified load balancer. Use this operation to add or alter the rules in a rule set.
    
    To add a new rule to a set, the body must include both the new rule to add and the existing rules to retain.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateSSLCipherSuite
```
Future<UpdateSSLCipherSuiteResponse> updateSSLCipherSuite(UpdateSSLCipherSuiteRequest request,
                                                          AsyncHandler<UpdateSSLCipherSuiteRequest,UpdateSSLCipherSuiteResponse> handler)
```
    Updates an existing SSL cipher suite for the specified load balancer.
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

Interface LoadBalancerAsync

Method Summary

Methods inherited from interface java.lang.AutoCloseable

Method Detail

refreshClient

setEndpoint

getEndpoint

setRegion

setRegion

useRealmSpecificEndpointTemplate

changeLoadBalancerCompartment

createBackend

createBackendSet

createCertificate

createHostname

createListener

createLoadBalancer

createPathRouteSet

createRoutingPolicy

createRuleSet

createSSLCipherSuite

deleteBackend

deleteBackendSet

deleteCertificate

deleteHostname

deleteListener

deleteLoadBalancer

deletePathRouteSet

deleteRoutingPolicy

deleteRuleSet

deleteSSLCipherSuite

getBackend

getBackendHealth

getBackendSet

getBackendSetHealth

getHealthChecker

getHostname

getLoadBalancer

getLoadBalancerHealth

getPathRouteSet

getRoutingPolicy

getRuleSet

getSSLCipherSuite

getWorkRequest

listBackendSets

listBackends

listCertificates

listHostnames

listListenerRules

listLoadBalancerHealths

listLoadBalancers

listPathRouteSets

listPolicies

listProtocols

listRoutingPolicies

listRuleSets

listSSLCipherSuites

listShapes

listWorkRequests

updateBackend

updateBackendSet

updateHealthChecker

updateHostname

updateListener

updateLoadBalancer

updateLoadBalancerShape

updateNetworkSecurityGroups

updatePathRouteSet

updateRoutingPolicy

updateRuleSet

updateSSLCipherSuite