Package com.oracle.bmc.fleetappsmanagement

Interface FleetAppsManagementOperationsAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    FleetAppsManagementOperationsAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20250228")
public interface FleetAppsManagementOperationsAsync
extends AutoCloseable
    Fleet Application Management provides a centralized platform to help you automate resource management tasks, validate patch compliance, and enhance operational efficiency across an enterprise.

    • 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

      • createPatch

        Future<CreatePatchResponse> createPatch​(CreatePatchRequest request,
                                        AsyncHandler<CreatePatchRequest,​CreatePatchResponse> handler)
        Creates a new 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.

      • deletePatch

        Future<DeletePatchResponse> deletePatch​(DeletePatchRequest request,
                                        AsyncHandler<DeletePatchRequest,​DeletePatchResponse> handler)
        Deletes the patch specified by identifier.
        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.

      • deleteSchedulerJob

        Future<DeleteSchedulerJobResponse> deleteSchedulerJob​(DeleteSchedulerJobRequest request,
                                                      AsyncHandler<DeleteSchedulerJobRequest,​DeleteSchedulerJobResponse> handler)
        Deletes the schedule job specified by an identifier.
        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.

      • getExecution

        Future<GetExecutionResponse> getExecution​(GetExecutionRequest request,
                                          AsyncHandler<GetExecutionRequest,​GetExecutionResponse> handler)
        Get Task Execution by Identifier for a Resource within an action group.
        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.

      • getJobActivity

        Future<GetJobActivityResponse> getJobActivity​(GetJobActivityRequest request,
                                              AsyncHandler<GetJobActivityRequest,​GetJobActivityResponse> handler)
        Gets activity details by identifier for a job.
        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.

      • getPatch

        Future<GetPatchResponse> getPatch​(GetPatchRequest request,
                                  AsyncHandler<GetPatchRequest,​GetPatchResponse> handler)
        Gets a Patch by identifier.
        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.

      • getSchedulerDefinition

        Future<GetSchedulerDefinitionResponse> getSchedulerDefinition​(GetSchedulerDefinitionRequest request,
                                                              AsyncHandler<GetSchedulerDefinitionRequest,​GetSchedulerDefinitionResponse> handler)
        Get the details of a SchedulerDefinition that performs lifecycle management operations.
        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.

      • getSchedulerJob

        Future<GetSchedulerJobResponse> getSchedulerJob​(GetSchedulerJobRequest request,
                                                AsyncHandler<GetSchedulerJobRequest,​GetSchedulerJobResponse> handler)
        Get the details of a lifecycle management operations job in Fleet Application Management.
        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.

      • listComplianceRecords

        Future<ListComplianceRecordsResponse> listComplianceRecords​(ListComplianceRecordsRequest request,
                                                            AsyncHandler<ListComplianceRecordsRequest,​ListComplianceRecordsResponse> handler)
        Gets a list of complianceDetails.
        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.

      • listExecutions

        Future<ListExecutionsResponse> listExecutions​(ListExecutionsRequest request,
                                              AsyncHandler<ListExecutionsRequest,​ListExecutionsResponse> handler)
        Returns a list of Task Executions for a 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.

      • listInventoryRecords

        Future<ListInventoryRecordsResponse> listInventoryRecords​(ListInventoryRecordsRequest request,
                                                          AsyncHandler<ListInventoryRecordsRequest,​ListInventoryRecordsResponse> handler)
        Gets a list of inventoryDetails.
        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)
        Returns a list of all the Patches in the specified compartment.

        The query parameter compartmentId is required unless the query parameter id is specified.

        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.

      • listResources

        Future<ListResourcesResponse> listResources​(ListResourcesRequest request,
                                            AsyncHandler<ListResourcesRequest,​ListResourcesResponse> handler)
        Returns a list of resources for an Activity Execution.
        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.

      • listScheduledFleets

        Future<ListScheduledFleetsResponse> listScheduledFleets​(ListScheduledFleetsRequest request,
                                                        AsyncHandler<ListScheduledFleetsRequest,​ListScheduledFleetsResponse> handler)
        Returns a list of ScheduledFleets.
        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.

      • listSchedulerDefinitions

        Future<ListSchedulerDefinitionsResponse> listSchedulerDefinitions​(ListSchedulerDefinitionsRequest request,
                                                                  AsyncHandler<ListSchedulerDefinitionsRequest,​ListSchedulerDefinitionsResponse> handler)
        Returns a list of all the Schedule Definitions in the specified compartment.

        The query parameter compartmentId is required unless the query parameter id is specified.

        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.

      • listSchedulerExecutions

        Future<ListSchedulerExecutionsResponse> listSchedulerExecutions​(ListSchedulerExecutionsRequest request,
                                                                AsyncHandler<ListSchedulerExecutionsRequest,​ListSchedulerExecutionsResponse> handler)
        Returns a list of all Fleets that are scheduled.
        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.

      • listSchedulerJobs

        Future<ListSchedulerJobsResponse> listSchedulerJobs​(ListSchedulerJobsRequest request,
                                                    AsyncHandler<ListSchedulerJobsRequest,​ListSchedulerJobsResponse> handler)
        Returns a list of all schedule jobs in the specified compartment.

        The query parameter compartmentId is required unless the query parameter id is specified.

        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.

      • listSteps

        Future<ListStepsResponse> listSteps​(ListStepsRequest request,
                                    AsyncHandler<ListStepsRequest,​ListStepsResponse> handler)
        Returns a list of Steps for an Activity Execution.
        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.

      • manageJobExecution

        Future<ManageJobExecutionResponse> manageJobExecution​(ManageJobExecutionRequest request,
                                                      AsyncHandler<ManageJobExecutionRequest,​ManageJobExecutionResponse> handler)
        Manage execution actions for a Job like retrying or pausing a task.
        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.

      • updatePatch

        Future<UpdatePatchResponse> updatePatch​(UpdatePatchRequest request,
                                        AsyncHandler<UpdatePatchRequest,​UpdatePatchResponse> handler)
        Updates the patch specified by the identifier.
        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.

      • updateSchedulerDefinition

        Future<UpdateSchedulerDefinitionResponse> updateSchedulerDefinition​(UpdateSchedulerDefinitionRequest request,
                                                                    AsyncHandler<UpdateSchedulerDefinitionRequest,​UpdateSchedulerDefinitionResponse> handler)
        Update the details of a SchedulerDefinition that performs lifecycle management operations.
        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.

      • updateSchedulerJob

        Future<UpdateSchedulerJobResponse> updateSchedulerJob​(UpdateSchedulerJobRequest request,
                                                      AsyncHandler<UpdateSchedulerJobRequest,​UpdateSchedulerJobResponse> handler)
        Updates certain attributes for the specified schedule job.
        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.