Package com.oracle.bmc.queue

Interface QueueAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    QueueAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20210201")
public interface QueueAsync
extends AutoCloseable
    Use the Queue API to produce and consume messages, create queues, and manage related items.

    For more information, see Queue.

    • 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

      • deleteMessage

        Future<DeleteMessageResponse> deleteMessage​(DeleteMessageRequest request,
                                            AsyncHandler<DeleteMessageRequest,​DeleteMessageResponse> handler)
        Deletes the message represented by the receipt from the queue.

        You must use the messages endpoint to delete messages. The messages endpoint may be different for different queues. Use getQueue to find the queue’s messagesEndpoint.

        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.

      • deleteMessages

        Future<DeleteMessagesResponse> deleteMessages​(DeleteMessagesRequest request,
                                              AsyncHandler<DeleteMessagesRequest,​DeleteMessagesResponse> handler)
        Deletes multiple messages from the queue or the consumer group.

        Only messages from the same queue/consumer group can be deleted at once. You must use the messages endpoint to delete messages. The messages endpoint may be different for different queues. Use getQueue to find the queue’s messagesEndpoint.

        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.

      • getMessages

        Future<GetMessagesResponse> getMessages​(GetMessagesRequest request,
                                        AsyncHandler<GetMessagesRequest,​GetMessagesResponse> handler)
        Consumes messages from the queue.

        You must use the messages endpoint to consume messages. The messages endpoint may be different for different queues. Use getQueue to find the queue’s messagesEndpoint. GetMessages accepts optional channelFilter query parameter that can filter source channels of the messages. When channelFilter is present, service will return available messages from the channel which ID exactly matched the filter. When filter is not specified, messages will be returned from a random non-empty channel within a queue.

        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.

      • getStats

        Future<GetStatsResponse> getStats​(GetStatsRequest request,
                                  AsyncHandler<GetStatsRequest,​GetStatsResponse> handler)
        Gets the statistics for the queue and its dead letter queue.

        You must use the messages endpoint to get a queue’s statistics. The messages endpoint may be different for different queues. Use getQueue to find the queue’s messagesEndpoint.

        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.

      • listChannels

        Future<ListChannelsResponse> listChannels​(ListChannelsRequest request,
                                          AsyncHandler<ListChannelsRequest,​ListChannelsResponse> handler)
        Gets the list of IDs of non-empty channels.

        It will return an approximate list of IDs of non-empty channels. That information is based on the queue level statistics. API supports optional channelFilter parameter which will filter the returned results according to the specified filter. List of channel IDs is approximate, because statistics is refreshed once per-second, and that list represents a snapshot of the past information. API is paginated.

        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.

      • putMessages

        Future<PutMessagesResponse> putMessages​(PutMessagesRequest request,
                                        AsyncHandler<PutMessagesRequest,​PutMessagesResponse> handler)
        Puts messages into the queue.

        You must use the messages endpoint to produce messages. The messages endpoint may be different for different queues. Use getQueue to find the queue’s messagesEndpoint.

        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.

      • updateMessage

        Future<UpdateMessageResponse> updateMessage​(UpdateMessageRequest request,
                                            AsyncHandler<UpdateMessageRequest,​UpdateMessageResponse> handler)
        Updates the visibility of the message represented by the receipt.

        You must use the messages endpoint to update messages. The messages endpoint may be different for different queues. Use getQueue to find the queue’s messagesEndpoint.

        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.

      • updateMessages

        Future<UpdateMessagesResponse> updateMessages​(UpdateMessagesRequest request,
                                              AsyncHandler<UpdateMessagesRequest,​UpdateMessagesResponse> handler)
        Updates multiple messages in the queue or the consumer group.

        Only messages from the same queue/consumer group can be updated at once. You must use the messages endpoint to update messages. The messages endpoint may be different for different queues. Use getQueue to find the queue’s messagesEndpoint.

        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.