Package com.oracle.bmc.sch

Interface ServiceConnectorAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    ServiceConnectorAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20200909")
public interface ServiceConnectorAsync
extends AutoCloseable
    Use the Connector Hub API to transfer data between services in Oracle Cloud Infrastructure.

    For more information about Connector Hub, see the Connector Hub documentation. Connector Hub is formerly known as Service Connector Hub.

    • 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

      • activateServiceConnector

        Future<ActivateServiceConnectorResponse> activateServiceConnector​(ActivateServiceConnectorRequest request,
                                                                  AsyncHandler<ActivateServiceConnectorRequest,​ActivateServiceConnectorResponse> handler)
        Activates the specified connector.

        After you send your request, the connector's state is temporarily UPDATING. When the state changes to ACTIVE, data begins transferring from the source service to the target service. For more information, see [Activating a Connector](https://docs.oracle.com/iaas/Content/connector-hub/activate-service-connector.htm).

        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.

      • createServiceConnector

        Future<CreateServiceConnectorResponse> createServiceConnector​(CreateServiceConnectorRequest request,
                                                              AsyncHandler<CreateServiceConnectorRequest,​CreateServiceConnectorResponse> handler)
        Creates a new connector in the specified compartment.

        A connector is a logically defined flow for moving data from a source service to a destination service in Oracle Cloud Infrastructure. For more information, see Creating a Connector. For general information about connectors, see Overview of Connector Hub.

        For purposes of access control, you must provide the [OCID](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the compartment where you want the connector to reside. Notice that the connector doesn't have to be in the same compartment as the source or target services. For information about access control and compartments, see [Overview of the IAM Service](https://docs.oracle.com/iaas/Content/Identity/Concepts/overview.htm).

        After you send your request, the new connector's state is temporarily CREATING. When the state changes to ACTIVE, data begins transferring from the source service to the target service. For instructions on deactivating and activating connectors, see [Activating a Connector](https://docs.oracle.com/iaas/Content/connector-hub/activate-service-connector.htm).

        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.

      • deactivateServiceConnector

        Future<DeactivateServiceConnectorResponse> deactivateServiceConnector​(DeactivateServiceConnectorRequest request,
                                                                      AsyncHandler<DeactivateServiceConnectorRequest,​DeactivateServiceConnectorResponse> handler)
        Deactivates the specified connector.

        After you send your request, the connector's state is temporarily UPDATING and any data transfer stops. The state then changes to INACTIVE. For more information, see [Deactivating a Connector](https://docs.oracle.com/iaas/Content/connector-hub/deactivate-service-connector.htm).

        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.

      • deleteServiceConnector

        Future<DeleteServiceConnectorResponse> deleteServiceConnector​(DeleteServiceConnectorRequest request,
                                                              AsyncHandler<DeleteServiceConnectorRequest,​DeleteServiceConnectorResponse> handler)
        Deletes the specified connector.

        For more information, see Deleting a Connector.

        After you send your request, the connector's state is temporarily DELETING and any data transfer stops. The state then changes to DELETED.

        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.

      • getServiceConnector

        Future<GetServiceConnectorResponse> getServiceConnector​(GetServiceConnectorRequest request,
                                                        AsyncHandler<GetServiceConnectorRequest,​GetServiceConnectorResponse> handler)
        Gets the specified connector’s configuration information.

        For more information, see Getting a Connector.

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

      • getWorkRequest

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                              AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets the details of the specified work request.

        For more information, see Getting a Work Request’s 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.

      • listWorkRequests

        Future<ListWorkRequestsResponse> listWorkRequests​(ListWorkRequestsRequest request,
                                                  AsyncHandler<ListWorkRequestsRequest,​ListWorkRequestsResponse> handler)
        Lists the work requests in the specified compartment.

        For more information, see Listing Work Requests.

        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.

      • updateServiceConnector

        Future<UpdateServiceConnectorResponse> updateServiceConnector​(UpdateServiceConnectorRequest request,
                                                              AsyncHandler<UpdateServiceConnectorRequest,​UpdateServiceConnectorResponse> handler)
        Updates the configuration information for the specified connector.

        For more information, see Updating a Connector.

        After you send your request, the connector's state is temporarily UPDATING and any data transfer pauses. The state then changes back to its original value: if ACTIVE, then data transfer resumes.

        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.