Package com.oracle.bmc.bds

Interface BdsAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    BdsAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20190531")
public interface BdsAsync
extends AutoCloseable
    REST API for Oracle Big Data Service.

    Use this API to build, deploy, and manage fully elastic Big Data Service clusters. Build on Hadoop, Spark and Data Science distributions, which can be fully integrated with existing enterprise data in Oracle Database and Oracle applications.

    • 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

      • addBlockStorage

        Future<AddBlockStorageResponse> addBlockStorage​(AddBlockStorageRequest request,
                                                AsyncHandler<AddBlockStorageRequest,​AddBlockStorageResponse> handler)
        Adds block storage to existing worker/compute only worker nodes.

        The same amount of storage will be added to all worker/compute only worker nodes. No change will be made to storage that is already attached. Block storage cannot be removed.

        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.

      • addCloudSql

        Future<AddCloudSqlResponse> addCloudSql​(AddCloudSqlRequest request,
                                        AsyncHandler<AddCloudSqlRequest,​AddCloudSqlResponse> handler)
        Adds Cloud SQL to your cluster.

        You can use Cloud SQL to query against non-relational data stored in multiple big data sources, including Apache Hive, HDFS, Oracle NoSQL Database, and Apache HBase. Adding Cloud SQL adds a query server node to the cluster and creates cell servers on all the worker nodes in the 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.

      • addKafka

        Future<AddKafkaResponse> addKafka​(AddKafkaRequest request,
                                  AsyncHandler<AddKafkaRequest,​AddKafkaResponse> handler)
        Adds Kafka to 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.

      • addMasterNodes

        Future<AddMasterNodesResponse> addMasterNodes​(AddMasterNodesRequest request,
                                              AsyncHandler<AddMasterNodesRequest,​AddMasterNodesResponse> handler)
        Increases the size (scales out) of a cluster by adding master nodes.

        The added master nodes will have the same shape and will have the same amount of attached block storage as other master nodes in the 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.

      • addUtilityNodes

        Future<AddUtilityNodesResponse> addUtilityNodes​(AddUtilityNodesRequest request,
                                                AsyncHandler<AddUtilityNodesRequest,​AddUtilityNodesResponse> handler)
        Increases the size (scales out) of a cluster by adding utility nodes.

        The added utility nodes will have the same shape and will have the same amount of attached block storage as other utility nodes in the 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.

      • addWorkerNodes

        Future<AddWorkerNodesResponse> addWorkerNodes​(AddWorkerNodesRequest request,
                                              AsyncHandler<AddWorkerNodesRequest,​AddWorkerNodesResponse> handler)
        Increases the size (scales out) a cluster by adding worker nodes(data/compute).

        The added worker nodes will have the same shape and will have the same amount of attached block storage as other worker nodes in the 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.

      • backupNode

        Future<BackupNodeResponse> backupNode​(BackupNodeRequest request,
                                      AsyncHandler<BackupNodeRequest,​BackupNodeResponse> handler)
        Takes a backup of of given nodes.
        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.

      • certificateServiceInfo

        Future<CertificateServiceInfoResponse> certificateServiceInfo​(CertificateServiceInfoRequest request,
                                                              AsyncHandler<CertificateServiceInfoRequest,​CertificateServiceInfoResponse> handler)
        A list of services and their certificate details.
        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.

      • changeShape

        Future<ChangeShapeResponse> changeShape​(ChangeShapeRequest request,
                                        AsyncHandler<ChangeShapeRequest,​ChangeShapeResponse> handler)
        Changes the size of a cluster by scaling up or scaling down the nodes.

        Nodes are scaled up or down by changing the shapes of all the nodes of the same type to the next larger or smaller shape. The node types are master, utility, worker, and Cloud SQL. Only nodes with VM-STANDARD shapes can be scaled.

        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.

      • createBdsApiKey

        Future<CreateBdsApiKeyResponse> createBdsApiKey​(CreateBdsApiKeyRequest request,
                                                AsyncHandler<CreateBdsApiKeyRequest,​CreateBdsApiKeyResponse> handler)
        Create an API key on behalf of the specified user.
        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.

      • createBdsInstance

        Future<CreateBdsInstanceResponse> createBdsInstance​(CreateBdsInstanceRequest request,
                                                    AsyncHandler<CreateBdsInstanceRequest,​CreateBdsInstanceResponse> handler)
        Creates a Big Data Service 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.

      • deleteBdsApiKey

        Future<DeleteBdsApiKeyResponse> deleteBdsApiKey​(DeleteBdsApiKeyRequest request,
                                                AsyncHandler<DeleteBdsApiKeyRequest,​DeleteBdsApiKeyResponse> handler)
        Deletes the user’s API key represented by the provided ID.
        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.

      • deleteBdsInstance

        Future<DeleteBdsInstanceResponse> deleteBdsInstance​(DeleteBdsInstanceRequest request,
                                                    AsyncHandler<DeleteBdsInstanceRequest,​DeleteBdsInstanceResponse> handler)
        Deletes the cluster identified by the given ID.
        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.

      • deleteIdentityConfiguration

        Future<DeleteIdentityConfigurationResponse> deleteIdentityConfiguration​(DeleteIdentityConfigurationRequest request,
                                                                        AsyncHandler<DeleteIdentityConfigurationRequest,​DeleteIdentityConfigurationResponse> handler)
        Delete the identity configuration represented by the provided ID.

        Deletion is only allowed if this identity configuration is not associated with any active IAM user sync configuration or UPST 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.

      • deleteNodeBackup

        Future<DeleteNodeBackupResponse> deleteNodeBackup​(DeleteNodeBackupRequest request,
                                                  AsyncHandler<DeleteNodeBackupRequest,​DeleteNodeBackupResponse> handler)
        Delete the NodeBackup represented by the provided ID.
        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.

      • disableCertificate

        Future<DisableCertificateResponse> disableCertificate​(DisableCertificateRequest request,
                                                      AsyncHandler<DisableCertificateRequest,​DisableCertificateResponse> handler)
        Disabling TLS/SSL for various ODH services running on the BDS 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.

      • enableCertificate

        Future<EnableCertificateResponse> enableCertificate​(EnableCertificateRequest request,
                                                    AsyncHandler<EnableCertificateRequest,​EnableCertificateResponse> handler)
        Configuring TLS/SSL for various ODH services running on the BDS 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.

      • getBdsApiKey

        Future<GetBdsApiKeyResponse> getBdsApiKey​(GetBdsApiKeyRequest request,
                                          AsyncHandler<GetBdsApiKeyRequest,​GetBdsApiKeyResponse> handler)
        Returns the user’s API key information for the given ID.
        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.

      • getBdsInstance

        Future<GetBdsInstanceResponse> getBdsInstance​(GetBdsInstanceRequest request,
                                              AsyncHandler<GetBdsInstanceRequest,​GetBdsInstanceResponse> handler)
        Returns information about the Big Data Service cluster identified by the given ID.
        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.

      • getNodeBackup

        Future<GetNodeBackupResponse> getNodeBackup​(GetNodeBackupRequest request,
                                            AsyncHandler<GetNodeBackupRequest,​GetNodeBackupResponse> handler)
        Returns details of NodeBackup identified by the given ID.
        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.

      • getOsPatchDetails

        Future<GetOsPatchDetailsResponse> getOsPatchDetails​(GetOsPatchDetailsRequest request,
                                                    AsyncHandler<GetOsPatchDetailsRequest,​GetOsPatchDetailsResponse> handler)
        Get the details of an os patch
        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)
        Returns the status of the work request identified by the given ID.
        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.

      • installOsPatch

        Future<InstallOsPatchResponse> installOsPatch​(InstallOsPatchRequest request,
                                              AsyncHandler<InstallOsPatchRequest,​InstallOsPatchResponse> handler)
        Install an os patch on 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.

      • installPatch

        Future<InstallPatchResponse> installPatch​(InstallPatchRequest request,
                                          AsyncHandler<InstallPatchRequest,​InstallPatchResponse> handler)
        Install the specified patch to this 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.

      • listBdsApiKeys

        Future<ListBdsApiKeysResponse> listBdsApiKeys​(ListBdsApiKeysRequest request,
                                              AsyncHandler<ListBdsApiKeysRequest,​ListBdsApiKeysResponse> handler)
        Returns a list of all API keys associated with this Big Data Service 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.

      • listBdsClusterVersions

        Future<ListBdsClusterVersionsResponse> listBdsClusterVersions​(ListBdsClusterVersionsRequest request,
                                                              AsyncHandler<ListBdsClusterVersionsRequest,​ListBdsClusterVersionsResponse> handler)
        Returns a list of cluster versions with associated odh and bds versions.
        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.

      • listBdsInstances

        Future<ListBdsInstancesResponse> listBdsInstances​(ListBdsInstancesRequest request,
                                                  AsyncHandler<ListBdsInstancesRequest,​ListBdsInstancesResponse> handler)
        Returns a list of all Big Data Service clusters 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.

      • listIdentityConfigurations

        Future<ListIdentityConfigurationsResponse> listIdentityConfigurations​(ListIdentityConfigurationsRequest request,
                                                                      AsyncHandler<ListIdentityConfigurationsRequest,​ListIdentityConfigurationsResponse> handler)
        Returns a list of all identity configurations associated with this Big Data Service 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.

      • listNodeBackups

        Future<ListNodeBackupsResponse> listNodeBackups​(ListNodeBackupsRequest request,
                                                AsyncHandler<ListNodeBackupsRequest,​ListNodeBackupsResponse> handler)
        Returns information about the node Backups.
        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.

      • listOsPatches

        Future<ListOsPatchesResponse> listOsPatches​(ListOsPatchesRequest request,
                                            AsyncHandler<ListOsPatchesRequest,​ListOsPatchesResponse> handler)
        List all available os patches for a given 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.

      • listPatchHistories

        Future<ListPatchHistoriesResponse> listPatchHistories​(ListPatchHistoriesRequest request,
                                                      AsyncHandler<ListPatchHistoriesRequest,​ListPatchHistoriesResponse> handler)
        List the patch history of this 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.

      • listPatches

        Future<ListPatchesResponse> listPatches​(ListPatchesRequest request,
                                        AsyncHandler<ListPatchesRequest,​ListPatchesResponse> handler)
        List all the available patches for this 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.

      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                            AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Returns a paginated list of errors for a work request identified by the given ID.
        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)
        Returns a paginated list of logs for a given 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)
        Lists the 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.

      • refreshConfidentialApplication

        Future<RefreshConfidentialApplicationResponse> refreshConfidentialApplication​(RefreshConfidentialApplicationRequest request,
                                                                              AsyncHandler<RefreshConfidentialApplicationRequest,​RefreshConfidentialApplicationResponse> handler)
        Refresh confidential application for the given identity configuration in case of any update to the confidential application (e.g.

        regenerated client secret)

        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.

      • removeCloudSql

        Future<RemoveCloudSqlResponse> removeCloudSql​(RemoveCloudSqlRequest request,
                                              AsyncHandler<RemoveCloudSqlRequest,​RemoveCloudSqlResponse> handler)
        Removes Cloud SQL from the 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.

      • removeKafka

        Future<RemoveKafkaResponse> removeKafka​(RemoveKafkaRequest request,
                                        AsyncHandler<RemoveKafkaRequest,​RemoveKafkaResponse> handler)
        Remove Kafka from the 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.

      • removeNode

        Future<RemoveNodeResponse> removeNode​(RemoveNodeRequest request,
                                      AsyncHandler<RemoveNodeRequest,​RemoveNodeResponse> handler)
        Remove a single node of a Big Data Service 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.

      • renewCertificate

        Future<RenewCertificateResponse> renewCertificate​(RenewCertificateRequest request,
                                                  AsyncHandler<RenewCertificateRequest,​RenewCertificateResponse> handler)
        Renewing TLS/SSL for various ODH services running on the BDS 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.

      • replaceNode

        Future<ReplaceNodeResponse> replaceNode​(ReplaceNodeRequest request,
                                        AsyncHandler<ReplaceNodeRequest,​ReplaceNodeResponse> handler)
        Replaces a node of a Big Data Service cluster from backup.
        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.

      • restartNode

        Future<RestartNodeResponse> restartNode​(RestartNodeRequest request,
                                        AsyncHandler<RestartNodeRequest,​RestartNodeResponse> handler)
        Restarts a single node of a Big Data Service 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.

      • startBdsInstance

        Future<StartBdsInstanceResponse> startBdsInstance​(StartBdsInstanceRequest request,
                                                  AsyncHandler<StartBdsInstanceRequest,​StartBdsInstanceResponse> handler)
        Starts the BDS cluster that was stopped earlier.
        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.

      • stopBdsInstance

        Future<StopBdsInstanceResponse> stopBdsInstance​(StopBdsInstanceRequest request,
                                                AsyncHandler<StopBdsInstanceRequest,​StopBdsInstanceResponse> handler)
        Stops the BDS cluster that can be started at later point of time.
        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.

      • updateBdsInstance

        Future<UpdateBdsInstanceResponse> updateBdsInstance​(UpdateBdsInstanceRequest request,
                                                    AsyncHandler<UpdateBdsInstanceRequest,​UpdateBdsInstanceResponse> handler)
        Updates the Big Data Service cluster identified by the given ID.
        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.