Package com.oracle.bmc.streaming

Interface StreamAdminAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    StreamAdminAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20180418")
public interface StreamAdminAsync
extends AutoCloseable
    Use the Streaming API to produce and consume messages, create streams and stream pools, and manage related items.

    For more information, see Streaming.

    • 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

      • changeStreamCompartment

        Future<ChangeStreamCompartmentResponse> changeStreamCompartment​(ChangeStreamCompartmentRequest request,
                                                                AsyncHandler<ChangeStreamCompartmentRequest,​ChangeStreamCompartmentResponse> handler)
        Moves a resource into a different compartment.

        When provided, If-Match is checked against ETag values of the resource. The stream will also be moved into the default stream pool in the destination 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.

      • changeStreamPoolCompartment

        Future<ChangeStreamPoolCompartmentResponse> changeStreamPoolCompartment​(ChangeStreamPoolCompartmentRequest request,
                                                                        AsyncHandler<ChangeStreamPoolCompartmentRequest,​ChangeStreamPoolCompartmentResponse> handler)
        Moves a resource into a different compartment.

        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.

      • createConnectHarness

        Future<CreateConnectHarnessResponse> createConnectHarness​(CreateConnectHarnessRequest request,
                                                          AsyncHandler<CreateConnectHarnessRequest,​CreateConnectHarnessResponse> handler)
        Starts the provisioning of a new connect harness.

        To track the progress of the provisioning, you can periodically call ConnectHarness object tells you its current state.

        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.

      • createStream

        Future<CreateStreamResponse> createStream​(CreateStreamRequest request,
                                          AsyncHandler<CreateStreamRequest,​CreateStreamResponse> handler)
        Starts the provisioning of a new stream.

        The stream will be created in the given compartment id or stream pool id, depending on which parameter is specified. Compartment id and stream pool id cannot be specified at the same time. To track the progress of the provisioning, you can periodically call getStream. In the response, the lifecycleState parameter of the Stream object tells you its current state.

        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.

      • createStreamPool

        Future<CreateStreamPoolResponse> createStreamPool​(CreateStreamPoolRequest request,
                                                  AsyncHandler<CreateStreamPoolRequest,​CreateStreamPoolResponse> handler)
        Starts the provisioning of a new stream pool.

        To track the progress of the provisioning, you can periodically call GetStreamPool. In the response, the lifecycleState parameter of the object tells you its current state.

        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.

      • deleteConnectHarness

        Future<DeleteConnectHarnessResponse> deleteConnectHarness​(DeleteConnectHarnessRequest request,
                                                          AsyncHandler<DeleteConnectHarnessRequest,​DeleteConnectHarnessResponse> handler)
        Deletes a connect harness and its content.

        Connect harness contents are deleted immediately. The service retains records of the connect harness itself for 90 days after deletion. The lifecycleState parameter of the ConnectHarness object changes to DELETING and the connect harness becomes inaccessible for read or write operations. To verify that a connect harness has been deleted, make a getConnectHarness request. If the call returns the connect harness’s lifecycle state as DELETED, then the connect harness has been deleted. If the call returns a "404 Not Found" error, that means all records of the connect harness have been 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.

      • deleteStream

        Future<DeleteStreamResponse> deleteStream​(DeleteStreamRequest request,
                                          AsyncHandler<DeleteStreamRequest,​DeleteStreamResponse> handler)
        Deletes a stream and its content.

        Stream contents are deleted immediately. The service retains records of the stream itself for 90 days after deletion. The lifecycleState parameter of the Stream object changes to DELETING and the stream becomes inaccessible for read or write operations. To verify that a stream has been deleted, make a getStream request. If the call returns the stream’s lifecycle state as DELETED, then the stream has been deleted. If the call returns a "404 Not Found" error, that means all records of the stream have been 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.

      • deleteStreamPool

        Future<DeleteStreamPoolResponse> deleteStreamPool​(DeleteStreamPoolRequest request,
                                                  AsyncHandler<DeleteStreamPoolRequest,​DeleteStreamPoolResponse> handler)
        Deletes a stream pool.

        All containing streams will also be deleted. The default stream pool of a compartment cannot be 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.

      • getConnectHarness

        Future<GetConnectHarnessResponse> getConnectHarness​(GetConnectHarnessRequest request,
                                                    AsyncHandler<GetConnectHarnessRequest,​GetConnectHarnessResponse> handler)
        Gets detailed information about a connect harness.
        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.

      • getStream

        Future<GetStreamResponse> getStream​(GetStreamRequest request,
                                    AsyncHandler<GetStreamRequest,​GetStreamResponse> handler)
        Gets detailed information about a stream, including the number of partitions.
        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.

      • getStreamPool

        Future<GetStreamPoolResponse> getStreamPool​(GetStreamPoolRequest request,
                                            AsyncHandler<GetStreamPoolRequest,​GetStreamPoolResponse> handler)
        Gets detailed information about the stream pool, such as Kafka settings.
        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.

      • listConnectHarnesses

        Future<ListConnectHarnessesResponse> listConnectHarnesses​(ListConnectHarnessesRequest request,
                                                          AsyncHandler<ListConnectHarnessesRequest,​ListConnectHarnessesResponse> handler)
        Lists the connectharness.
        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.

      • listStreamPools

        Future<ListStreamPoolsResponse> listStreamPools​(ListStreamPoolsRequest request,
                                                AsyncHandler<ListStreamPoolsRequest,​ListStreamPoolsResponse> handler)
        List the stream pools for a given compartment 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.

      • listStreams

        Future<ListStreamsResponse> listStreams​(ListStreamsRequest request,
                                        AsyncHandler<ListStreamsRequest,​ListStreamsResponse> handler)
        Lists the streams in the given compartment id.

        If the compartment id is specified, it will list streams in the compartment, regardless of their stream pool. If the stream pool id is specified, the action will be scoped to that stream pool. The compartment id and stream pool id cannot be specified at the same 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.

      • updateConnectHarness

        Future<UpdateConnectHarnessResponse> updateConnectHarness​(UpdateConnectHarnessRequest request,
                                                          AsyncHandler<UpdateConnectHarnessRequest,​UpdateConnectHarnessResponse> handler)
        Updates the tags applied to the connect harness.
        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.

      • updateStream

        Future<UpdateStreamResponse> updateStream​(UpdateStreamRequest request,
                                          AsyncHandler<UpdateStreamRequest,​UpdateStreamResponse> handler)
        Updates the stream.

        Only specified values will be updated.

        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.

      • updateStreamPool

        Future<UpdateStreamPoolResponse> updateStreamPool​(UpdateStreamPoolRequest request,
                                                  AsyncHandler<UpdateStreamPoolRequest,​UpdateStreamPoolResponse> handler)
        Updates the specified stream 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.