Package com.oracle.bmc.dataflow

Interface DataFlowAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    DataFlowAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20200129")
public interface DataFlowAsync
extends AutoCloseable
    Use the Data Flow APIs to run any Apache Spark application at any scale without deploying or managing any infrastructure.

    • 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

      • cascadingDeleteApplication

        Future<CascadingDeleteApplicationResponse> cascadingDeleteApplication​(CascadingDeleteApplicationRequest request,
                                                                      AsyncHandler<CascadingDeleteApplicationRequest,​CascadingDeleteApplicationResponse> handler)
        Deletes an application using an applicationId and terminates related runs.

        This operation will timeout in approximate 30 minutes if any related Runs are not terminated successfully.

        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.

      • changeApplicationCompartment

        Future<ChangeApplicationCompartmentResponse> changeApplicationCompartment​(ChangeApplicationCompartmentRequest request,
                                                                          AsyncHandler<ChangeApplicationCompartmentRequest,​ChangeApplicationCompartmentResponse> handler)
        Moves an application into a different compartment.

        When provided, If-Match is checked against ETag values of the resource. Associated resources, like runs, will not be automatically moved.

        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.

      • changePoolCompartment

        Future<ChangePoolCompartmentResponse> changePoolCompartment​(ChangePoolCompartmentRequest request,
                                                            AsyncHandler<ChangePoolCompartmentRequest,​ChangePoolCompartmentResponse> handler)
        Moves a pool into a different compartment.

        When provided, If-Match is checked against ETag values of the resource. Associated resources, like historical metrics, will not be automatically moved. The pool must be in a terminal state (STOPPED, FAILED) in order for it to be moved to a different compartment

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeRunCompartment

        Future<ChangeRunCompartmentResponse> changeRunCompartment​(ChangeRunCompartmentRequest request,
                                                          AsyncHandler<ChangeRunCompartmentRequest,​ChangeRunCompartmentResponse> handler)
        Moves a run into a different compartment.

        When provided, If-Match is checked against ETag values of the resource. Associated resources, like historical metrics, will not be automatically moved. The run must be in a terminal state (CANCELED, FAILED, SUCCEEDED) in order for it to be moved to a different compartment

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeSqlEndpointCompartment

        Future<ChangeSqlEndpointCompartmentResponse> changeSqlEndpointCompartment​(ChangeSqlEndpointCompartmentRequest request,
                                                                          AsyncHandler<ChangeSqlEndpointCompartmentRequest,​ChangeSqlEndpointCompartmentResponse> handler)
        Moves an Sql Endpoint from one compartment to another.

        When provided, If-Match is checked against ETag values of the Sql Endpoint.

        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.

      • createApplication

        Future<CreateApplicationResponse> createApplication​(CreateApplicationRequest request,
                                                    AsyncHandler<CreateApplicationRequest,​CreateApplicationResponse> handler)
        Creates an application.
        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.

      • createPool

        Future<CreatePoolResponse> createPool​(CreatePoolRequest request,
                                      AsyncHandler<CreatePoolRequest,​CreatePoolResponse> handler)
        Create a pool to be used by dataflow runs or applications.
        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.

      • createPrivateEndpoint

        Future<CreatePrivateEndpointResponse> createPrivateEndpoint​(CreatePrivateEndpointRequest request,
                                                            AsyncHandler<CreatePrivateEndpointRequest,​CreatePrivateEndpointResponse> handler)
        Creates a private endpoint to be used by applications.
        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.

      • createRun

        Future<CreateRunResponse> createRun​(CreateRunRequest request,
                                    AsyncHandler<CreateRunRequest,​CreateRunResponse> handler)
        Creates a run for an application.
        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.

      • createSqlEndpoint

        Future<CreateSqlEndpointResponse> createSqlEndpoint​(CreateSqlEndpointRequest request,
                                                    AsyncHandler<CreateSqlEndpointRequest,​CreateSqlEndpointResponse> handler)
        Create a new Sql Endpoint.
        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.

      • createStatement

        Future<CreateStatementResponse> createStatement​(CreateStatementRequest request,
                                                AsyncHandler<CreateStatementRequest,​CreateStatementResponse> handler)
        Executes a statement for a Session run.
        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.

      • deleteApplication

        Future<DeleteApplicationResponse> deleteApplication​(DeleteApplicationRequest request,
                                                    AsyncHandler<DeleteApplicationRequest,​DeleteApplicationResponse> handler)
        Deletes an application using an applicationId.
        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.

      • deletePool

        Future<DeletePoolResponse> deletePool​(DeletePoolRequest request,
                                      AsyncHandler<DeletePoolRequest,​DeletePoolResponse> handler)
        Deletes a pool using a poolId.
        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.

      • deletePrivateEndpoint

        Future<DeletePrivateEndpointResponse> deletePrivateEndpoint​(DeletePrivateEndpointRequest request,
                                                            AsyncHandler<DeletePrivateEndpointRequest,​DeletePrivateEndpointResponse> handler)
        Deletes a private endpoint using a privateEndpointId.
        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.

      • deleteRun

        Future<DeleteRunResponse> deleteRun​(DeleteRunRequest request,
                                    AsyncHandler<DeleteRunRequest,​DeleteRunResponse> handler)
        Cancels the specified run if it has not already completed or was previously cancelled.

        If a run is in progress, the executing job will be killed.

        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.

      • deleteSqlEndpoint

        Future<DeleteSqlEndpointResponse> deleteSqlEndpoint​(DeleteSqlEndpointRequest request,
                                                    AsyncHandler<DeleteSqlEndpointRequest,​DeleteSqlEndpointResponse> handler)
        Delete a Sql Endpoint resource, identified by the SqlEndpoint 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.

      • deleteStatement

        Future<DeleteStatementResponse> deleteStatement​(DeleteStatementRequest request,
                                                AsyncHandler<DeleteStatementRequest,​DeleteStatementResponse> handler)
        Cancels the specified statement for a Session run.
        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.

      • getApplication

        Future<GetApplicationResponse> getApplication​(GetApplicationRequest request,
                                              AsyncHandler<GetApplicationRequest,​GetApplicationResponse> handler)
        Retrieves an application using an applicationId.
        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.

      • getPool

        Future<GetPoolResponse> getPool​(GetPoolRequest request,
                                AsyncHandler<GetPoolRequest,​GetPoolResponse> handler)
        Retrieves a pool using a poolId.
        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.

      • getPrivateEndpoint

        Future<GetPrivateEndpointResponse> getPrivateEndpoint​(GetPrivateEndpointRequest request,
                                                      AsyncHandler<GetPrivateEndpointRequest,​GetPrivateEndpointResponse> handler)
        Retrieves an private endpoint using a privateEndpointId.
        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.

      • getRun

        Future<GetRunResponse> getRun​(GetRunRequest request,
                              AsyncHandler<GetRunRequest,​GetRunResponse> handler)
        Retrieves the run for the specified runId.
        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.

      • getRunLog

        Future<GetRunLogResponse> getRunLog​(GetRunLogRequest request,
                                    AsyncHandler<GetRunLogRequest,​GetRunLogResponse> handler)
        Retrieves the content of an run log.
        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.

      • getSqlEndpoint

        Future<GetSqlEndpointResponse> getSqlEndpoint​(GetSqlEndpointRequest request,
                                              AsyncHandler<GetSqlEndpointRequest,​GetSqlEndpointResponse> handler)
        Retrieves a SQL Endpoint using a sqlEndpointId.
        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.

      • getStatement

        Future<GetStatementResponse> getStatement​(GetStatementRequest request,
                                          AsyncHandler<GetStatementRequest,​GetStatementResponse> handler)
        Retrieves the statement corresponding to the statementId for a Session run specified by runId.
        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 status of the work request with the given OCID.
        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.

      • listApplications

        Future<ListApplicationsResponse> listApplications​(ListApplicationsRequest request,
                                                  AsyncHandler<ListApplicationsRequest,​ListApplicationsResponse> handler)
        Lists all applications in the specified compartment.

        Only one parameter other than compartmentId may also be included in a query. The query must include compartmentId. If the query does not include compartmentId, or includes compartmentId but two or more other parameters an error is returned.

        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.

      • listPools

        Future<ListPoolsResponse> listPools​(ListPoolsRequest request,
                                    AsyncHandler<ListPoolsRequest,​ListPoolsResponse> handler)
        Lists all pools in the specified compartment.

        The query must include compartmentId. The query may also include one other parameter. If the query does not include compartmentId, or includes compartmentId, but with two or more other parameters, an error is returned.

        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.

      • listPrivateEndpoints

        Future<ListPrivateEndpointsResponse> listPrivateEndpoints​(ListPrivateEndpointsRequest request,
                                                          AsyncHandler<ListPrivateEndpointsRequest,​ListPrivateEndpointsResponse> handler)
        Lists all private endpoints in the specified compartment.

        The query must include compartmentId. The query may also include one other parameter. If the query does not include compartmentId, or includes compartmentId, but with two or more other parameters, an error is returned.

        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.

      • listRunLogs

        Future<ListRunLogsResponse> listRunLogs​(ListRunLogsRequest request,
                                        AsyncHandler<ListRunLogsRequest,​ListRunLogsResponse> handler)
        Retrieves summaries of the run’s logs.
        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.

      • listRuns

        Future<ListRunsResponse> listRuns​(ListRunsRequest request,
                                  AsyncHandler<ListRunsRequest,​ListRunsResponse> handler)
        Lists all runs of an application in the specified compartment.

        Only one parameter other than compartmentId may also be included in a query. The query must include compartmentId. If the query does not include compartmentId, or includes compartmentId but two or more other parameters an error is returned.

        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.

      • listSqlEndpoints

        Future<ListSqlEndpointsResponse> listSqlEndpoints​(ListSqlEndpointsRequest request,
                                                  AsyncHandler<ListSqlEndpointsRequest,​ListSqlEndpointsResponse> handler)
        Lists all Sql Endpoints in the specified compartment.

        The query must include compartmentId or sqlEndpointId. If the query does not include either compartmentId or sqlEndpointId, an error is returned.

        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.

      • listStatements

        Future<ListStatementsResponse> listStatements​(ListStatementsRequest request,
                                              AsyncHandler<ListStatementsRequest,​ListStatementsResponse> handler)
        Lists all statements for a Session run.
        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)
        Return a (paginated) list of errors 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.

      • listWorkRequestLogs

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

      • startPool

        Future<StartPoolResponse> startPool​(StartPoolRequest request,
                                    AsyncHandler<StartPoolRequest,​StartPoolResponse> handler)
        Starts the dataflow pool for a given poolId.

        When provided, If-Match is checked against ETag values of the resource.

        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.

      • startSqlEndpoint

        Future<StartSqlEndpointResponse> startSqlEndpoint​(StartSqlEndpointRequest request,
                                                  AsyncHandler<StartSqlEndpointRequest,​StartSqlEndpointResponse> handler)
        Starts the SqlEndpoint for a given SqlEndpointId.

        When provided, If-Match is checked against ETag values of the resource.

        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.

      • stopPool

        Future<StopPoolResponse> stopPool​(StopPoolRequest request,
                                  AsyncHandler<StopPoolRequest,​StopPoolResponse> handler)
        Stops the dataflow pool for a given poolId.

        When provided, If-Match is checked against ETag values of the resource.

        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.

      • stopSqlEndpoint

        Future<StopSqlEndpointResponse> stopSqlEndpoint​(StopSqlEndpointRequest request,
                                                AsyncHandler<StopSqlEndpointRequest,​StopSqlEndpointResponse> handler)
        Stops the SqlEndpoint for a given SqlEndpointId.

        When provided, If-Match is checked against ETag values of the resource.

        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.

      • updateApplication

        Future<UpdateApplicationResponse> updateApplication​(UpdateApplicationRequest request,
                                                    AsyncHandler<UpdateApplicationRequest,​UpdateApplicationResponse> handler)
        Updates an application using an applicationId.
        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.

      • updatePool

        Future<UpdatePoolResponse> updatePool​(UpdatePoolRequest request,
                                      AsyncHandler<UpdatePoolRequest,​UpdatePoolResponse> handler)
        Updates a pool using a poolId.If changes to a pool doesn’t match a previously defined pool,then a 409 status code will be returned.This indicates that a conflict has been detected.
        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.

      • updatePrivateEndpoint

        Future<UpdatePrivateEndpointResponse> updatePrivateEndpoint​(UpdatePrivateEndpointRequest request,
                                                            AsyncHandler<UpdatePrivateEndpointRequest,​UpdatePrivateEndpointResponse> handler)
        Updates a private endpoint using a privateEndpointId.

        If changes to a private endpoint match a previously defined private endpoint, then a 409 status code will be returned. This indicates that a conflict has been detected.

        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.

      • updateRun

        Future<UpdateRunResponse> updateRun​(UpdateRunRequest request,
                                    AsyncHandler<UpdateRunRequest,​UpdateRunResponse> handler)
        Updates a run using a runId.
        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.

      • updateSqlEndpoint

        Future<UpdateSqlEndpointResponse> updateSqlEndpoint​(UpdateSqlEndpointRequest request,
                                                    AsyncHandler<UpdateSqlEndpointRequest,​UpdateSqlEndpointResponse> handler)
        Update a Sql Endpoint resource, identified by the SqlEndpoint 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.