Package com.oracle.bmc.loadbalancer

Interface LoadBalancerAsync

  • 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 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

      • 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.oracle.com/iaas/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.oracle.com/iaas/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.oracle.com/iaas/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.

      • 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.

      • 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.