Package com.oracle.bmc.containerengine

Interface ContainerEngineAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    ContainerEngineAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20180222")
public interface ContainerEngineAsync
extends AutoCloseable
    API for the Kubernetes Engine service (also known as the Container Engine for Kubernetes service).

    Use this API to build, deploy, and manage cloud-native applications. For more information, see Overview of Kubernetes Engine.

    • 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

      • completeCredentialRotation

        Future<CompleteCredentialRotationResponse> completeCredentialRotation​(CompleteCredentialRotationRequest request,
                                                                      AsyncHandler<CompleteCredentialRotationRequest,​CompleteCredentialRotationResponse> handler)
        Complete cluster credential rotation.

        Retire old credentials from kubernetes components.

        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.

      • createCluster

        Future<CreateClusterResponse> createCluster​(CreateClusterRequest request,
                                            AsyncHandler<CreateClusterRequest,​CreateClusterResponse> handler)
        Create a new cluster.
        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.

      • createKubeconfig

        Future<CreateKubeconfigResponse> createKubeconfig​(CreateKubeconfigRequest request,
                                                  AsyncHandler<CreateKubeconfigRequest,​CreateKubeconfigResponse> handler)
        Create the Kubeconfig YAML for a cluster.
        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.

      • createNodePool

        Future<CreateNodePoolResponse> createNodePool​(CreateNodePoolRequest request,
                                              AsyncHandler<CreateNodePoolRequest,​CreateNodePoolResponse> handler)
        Create a new node pool.
        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.

      • createVirtualNodePool

        Future<CreateVirtualNodePoolResponse> createVirtualNodePool​(CreateVirtualNodePoolRequest request,
                                                            AsyncHandler<CreateVirtualNodePoolRequest,​CreateVirtualNodePoolResponse> handler)
        Create a new virtual node pool.
        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.

      • createWorkloadMapping

        Future<CreateWorkloadMappingResponse> createWorkloadMapping​(CreateWorkloadMappingRequest request,
                                                            AsyncHandler<CreateWorkloadMappingRequest,​CreateWorkloadMappingResponse> handler)
        Create the specified workloadMapping for a cluster.
        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.

      • deleteCluster

        Future<DeleteClusterResponse> deleteCluster​(DeleteClusterRequest request,
                                            AsyncHandler<DeleteClusterRequest,​DeleteClusterResponse> handler)
        Delete a cluster.
        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.

      • deleteNode

        Future<DeleteNodeResponse> deleteNode​(DeleteNodeRequest request,
                                      AsyncHandler<DeleteNodeRequest,​DeleteNodeResponse> handler)
        Delete node.
        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.

      • deleteNodePool

        Future<DeleteNodePoolResponse> deleteNodePool​(DeleteNodePoolRequest request,
                                              AsyncHandler<DeleteNodePoolRequest,​DeleteNodePoolResponse> handler)
        Delete a node pool.
        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.

      • deleteVirtualNodePool

        Future<DeleteVirtualNodePoolResponse> deleteVirtualNodePool​(DeleteVirtualNodePoolRequest request,
                                                            AsyncHandler<DeleteVirtualNodePoolRequest,​DeleteVirtualNodePoolResponse> handler)
        Delete a virtual node pool.
        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.

      • deleteWorkRequest

        Future<DeleteWorkRequestResponse> deleteWorkRequest​(DeleteWorkRequestRequest request,
                                                    AsyncHandler<DeleteWorkRequestRequest,​DeleteWorkRequestResponse> handler)
        Cancel a work request that has not started.
        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.

      • deleteWorkloadMapping

        Future<DeleteWorkloadMappingResponse> deleteWorkloadMapping​(DeleteWorkloadMappingRequest request,
                                                            AsyncHandler<DeleteWorkloadMappingRequest,​DeleteWorkloadMappingResponse> handler)
        Delete workloadMapping for a provisioned cluster.
        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.

      • disableAddon

        Future<DisableAddonResponse> disableAddon​(DisableAddonRequest request,
                                          AsyncHandler<DisableAddonRequest,​DisableAddonResponse> handler)
        Disable addon for a provisioned cluster.
        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.

      • getAddon

        Future<GetAddonResponse> getAddon​(GetAddonRequest request,
                                  AsyncHandler<GetAddonRequest,​GetAddonResponse> handler)
        Get the specified addon for a cluster.
        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.

      • getCluster

        Future<GetClusterResponse> getCluster​(GetClusterRequest request,
                                      AsyncHandler<GetClusterRequest,​GetClusterResponse> handler)
        Get the details of a cluster.
        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.

      • getClusterOptions

        Future<GetClusterOptionsResponse> getClusterOptions​(GetClusterOptionsRequest request,
                                                    AsyncHandler<GetClusterOptionsRequest,​GetClusterOptionsResponse> handler)
        Get options available for clusters.
        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.

      • getNodePool

        Future<GetNodePoolResponse> getNodePool​(GetNodePoolRequest request,
                                        AsyncHandler<GetNodePoolRequest,​GetNodePoolResponse> handler)
        Get the details of a node pool.
        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.

      • getNodePoolOptions

        Future<GetNodePoolOptionsResponse> getNodePoolOptions​(GetNodePoolOptionsRequest request,
                                                      AsyncHandler<GetNodePoolOptionsRequest,​GetNodePoolOptionsResponse> handler)
        Get options available for node pools.
        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.

      • getVirtualNode

        Future<GetVirtualNodeResponse> getVirtualNode​(GetVirtualNodeRequest request,
                                              AsyncHandler<GetVirtualNodeRequest,​GetVirtualNodeResponse> handler)
        Get the details of a virtual node.
        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.

      • getVirtualNodePool

        Future<GetVirtualNodePoolResponse> getVirtualNodePool​(GetVirtualNodePoolRequest request,
                                                      AsyncHandler<GetVirtualNodePoolRequest,​GetVirtualNodePoolResponse> handler)
        Get the details of a virtual node pool.
        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)
        Get 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.

      • getWorkloadMapping

        Future<GetWorkloadMappingResponse> getWorkloadMapping​(GetWorkloadMappingRequest request,
                                                      AsyncHandler<GetWorkloadMappingRequest,​GetWorkloadMappingResponse> handler)
        Get the specified workloadMapping for a cluster.
        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.

      • installAddon

        Future<InstallAddonResponse> installAddon​(InstallAddonRequest request,
                                          AsyncHandler<InstallAddonRequest,​InstallAddonResponse> handler)
        Install the specified addon for a cluster.
        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.

      • listAddonOptions

        Future<ListAddonOptionsResponse> listAddonOptions​(ListAddonOptionsRequest request,
                                                  AsyncHandler<ListAddonOptionsRequest,​ListAddonOptionsResponse> handler)
        Get list of supported addons for a specific kubernetes version.
        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.

      • listAddons

        Future<ListAddonsResponse> listAddons​(ListAddonsRequest request,
                                      AsyncHandler<ListAddonsRequest,​ListAddonsResponse> handler)
        List addon for a provisioned cluster.
        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.

      • listClusters

        Future<ListClustersResponse> listClusters​(ListClustersRequest request,
                                          AsyncHandler<ListClustersRequest,​ListClustersResponse> handler)
        List all the cluster objects in a 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.

      • listNodePools

        Future<ListNodePoolsResponse> listNodePools​(ListNodePoolsRequest request,
                                            AsyncHandler<ListNodePoolsRequest,​ListNodePoolsResponse> handler)
        List all the node pools in a compartment, and optionally filter by cluster.
        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.

      • listPodShapes

        Future<ListPodShapesResponse> listPodShapes​(ListPodShapesRequest request,
                                            AsyncHandler<ListPodShapesRequest,​ListPodShapesResponse> handler)
        List all the Pod Shapes in a 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.

      • listVirtualNodePools

        Future<ListVirtualNodePoolsResponse> listVirtualNodePools​(ListVirtualNodePoolsRequest request,
                                                          AsyncHandler<ListVirtualNodePoolsRequest,​ListVirtualNodePoolsResponse> handler)
        List all the virtual node pools in a compartment, and optionally filter by cluster.
        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.

      • listVirtualNodes

        Future<ListVirtualNodesResponse> listVirtualNodes​(ListVirtualNodesRequest request,
                                                  AsyncHandler<ListVirtualNodesRequest,​ListVirtualNodesResponse> handler)
        List virtual nodes in a virtual node pool.
        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.

      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                            AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Get the errors 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.

      • listWorkRequestLogs

        Future<ListWorkRequestLogsResponse> listWorkRequestLogs​(ListWorkRequestLogsRequest request,
                                                        AsyncHandler<ListWorkRequestLogsRequest,​ListWorkRequestLogsResponse> handler)
        Get the logs 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.

      • listWorkRequests

        Future<ListWorkRequestsResponse> listWorkRequests​(ListWorkRequestsRequest request,
                                                  AsyncHandler<ListWorkRequestsRequest,​ListWorkRequestsResponse> handler)
        List all work requests in a 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.

      • listWorkloadMappings

        Future<ListWorkloadMappingsResponse> listWorkloadMappings​(ListWorkloadMappingsRequest request,
                                                          AsyncHandler<ListWorkloadMappingsRequest,​ListWorkloadMappingsResponse> handler)
        List workloadMappings for a provisioned cluster.
        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.

      • startCredentialRotation

        Future<StartCredentialRotationResponse> startCredentialRotation​(StartCredentialRotationRequest request,
                                                                AsyncHandler<StartCredentialRotationRequest,​StartCredentialRotationResponse> handler)
        Start cluster credential rotation by adding new credentials, old credentials will still work after this 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.

      • updateAddon

        Future<UpdateAddonResponse> updateAddon​(UpdateAddonRequest request,
                                        AsyncHandler<UpdateAddonRequest,​UpdateAddonResponse> handler)
        Update addon details for a cluster.
        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.

      • updateCluster

        Future<UpdateClusterResponse> updateCluster​(UpdateClusterRequest request,
                                            AsyncHandler<UpdateClusterRequest,​UpdateClusterResponse> handler)
        Update the details of a cluster.
        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.

      • updateNodePool

        Future<UpdateNodePoolResponse> updateNodePool​(UpdateNodePoolRequest request,
                                              AsyncHandler<UpdateNodePoolRequest,​UpdateNodePoolResponse> handler)
        Update the details of a node pool.
        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.

      • updateVirtualNodePool

        Future<UpdateVirtualNodePoolResponse> updateVirtualNodePool​(UpdateVirtualNodePoolRequest request,
                                                            AsyncHandler<UpdateVirtualNodePoolRequest,​UpdateVirtualNodePoolResponse> handler)
        Update the details of a virtual node pool.
        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.

      • updateWorkloadMapping

        Future<UpdateWorkloadMappingResponse> updateWorkloadMapping​(UpdateWorkloadMappingRequest request,
                                                            AsyncHandler<UpdateWorkloadMappingRequest,​UpdateWorkloadMappingResponse> handler)
        Update workloadMapping details for a cluster.
        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.