Package com.oracle.bmc.jms

Interface JavaManagementServiceAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    JavaManagementServiceAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20210610")
public interface JavaManagementServiceAsync
extends AutoCloseable
    The APIs for the Fleet Management feature of Java Management Service to monitor and manage the usage of Java in your enterprise.

    Use these APIs to manage fleets, configure managed instances to report to fleets, and gain insights into the Java workloads running on these instances by carrying out basic and advanced features.

    • 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

      • cancelWorkRequest

        Future<CancelWorkRequestResponse> cancelWorkRequest​(CancelWorkRequestRequest request,
                                                    AsyncHandler<CancelWorkRequestRequest,​CancelWorkRequestResponse> handler)
        Deletes the work request 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.

      • changeFleetCompartment

        Future<ChangeFleetCompartmentResponse> changeFleetCompartment​(ChangeFleetCompartmentRequest request,
                                                              AsyncHandler<ChangeFleetCompartmentRequest,​ChangeFleetCompartmentResponse> handler)
        Move a specified Fleet into the compartment identified in the POST form.

        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.

      • createBlocklist

        Future<CreateBlocklistResponse> createBlocklist​(CreateBlocklistRequest request,
                                                AsyncHandler<CreateBlocklistRequest,​CreateBlocklistResponse> handler)
        Add a new record to the fleet blocklist.
        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.

      • createDrsFile

        Future<CreateDrsFileResponse> createDrsFile​(CreateDrsFileRequest request,
                                            AsyncHandler<CreateDrsFileRequest,​CreateDrsFileResponse> handler)
        Request to perform validation of the DRS file and create the file to the Object Storage.
        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.

      • createFleet

        Future<CreateFleetResponse> createFleet​(CreateFleetRequest request,
                                        AsyncHandler<CreateFleetRequest,​CreateFleetResponse> handler)
        Create a new Fleet using the information provided.

        `inventoryLog` is now a required parameter for CreateFleet API. Update existing applications using this API before July 15, 2022 to ensure the applications continue to work. See the [Service Change Notice](https://docs.oracle.com/en-us/iaas/Content/servicechanges.htm#JMS) for more details. Migrate existing fleets using the `UpdateFleet` API to set the `inventoryLog` parameter.

        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.

      • createJmsPlugin

        Future<CreateJmsPluginResponse> createJmsPlugin​(CreateJmsPluginRequest request,
                                                AsyncHandler<CreateJmsPluginRequest,​CreateJmsPluginResponse> handler)
        Registers an agent’s JmsPlugin, optionally attaching to an existing fleet of the tenancy.

        JmsPlugins registered fleet-less are created with lifecycle state INACTIVE. For the operation to be authorized, the agent must exist, and the authorized user requires JMS_PLUGIN_CREATE permission for the agent’s 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.

      • createTaskSchedule

        Future<CreateTaskScheduleResponse> createTaskSchedule​(CreateTaskScheduleRequest request,
                                                      AsyncHandler<CreateTaskScheduleRequest,​CreateTaskScheduleResponse> handler)
        Create a task schedule using the information provided.
        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.

      • deleteBlocklist

        Future<DeleteBlocklistResponse> deleteBlocklist​(DeleteBlocklistRequest request,
                                                AsyncHandler<DeleteBlocklistRequest,​DeleteBlocklistResponse> handler)
        Deletes the blocklist record 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.

      • deleteCryptoAnalysisResult

        Future<DeleteCryptoAnalysisResultResponse> deleteCryptoAnalysisResult​(DeleteCryptoAnalysisResultRequest request,
                                                                      AsyncHandler<DeleteCryptoAnalysisResultRequest,​DeleteCryptoAnalysisResultResponse> handler)
        Deletes the metadata for the result of a Crypto event analysis.

        The actual report shall remain in the object storage.

        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.

      • deleteDrsFile

        Future<DeleteDrsFileResponse> deleteDrsFile​(DeleteDrsFileRequest request,
                                            AsyncHandler<DeleteDrsFileRequest,​DeleteDrsFileResponse> handler)
        Request to delete the DRS file from the Object Storage.
        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.

      • deleteFleet

        Future<DeleteFleetResponse> deleteFleet​(DeleteFleetRequest request,
                                        AsyncHandler<DeleteFleetRequest,​DeleteFleetResponse> handler)
        Deletes the Fleet 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.

      • deleteJmsPlugin

        Future<DeleteJmsPluginResponse> deleteJmsPlugin​(DeleteJmsPluginRequest request,
                                                AsyncHandler<DeleteJmsPluginRequest,​DeleteJmsPluginResponse> handler)
        Deletes a JmsPlugin.

        The JmsPlugin may be visible for some time with state DELETED. Deleted plugins will not be able to communicate with the JMS service.

        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.

      • deleteTaskSchedule

        Future<DeleteTaskScheduleResponse> deleteTaskSchedule​(DeleteTaskScheduleRequest request,
                                                      AsyncHandler<DeleteTaskScheduleRequest,​DeleteTaskScheduleResponse> handler)
        Deletes the task schedule record 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.

      • disableDrs

        Future<DisableDrsResponse> disableDrs​(DisableDrsRequest request,
                                      AsyncHandler<DisableDrsRequest,​DisableDrsResponse> handler)
        Request to disable the DRS in the selected target in the Fleet.
        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.

      • enableDrs

        Future<EnableDrsResponse> enableDrs​(EnableDrsRequest request,
                                    AsyncHandler<EnableDrsRequest,​EnableDrsResponse> handler)
        Request to enable the DRS in the selected target in the Fleet.
        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.

      • generateAgentDeployScript

        Future<GenerateAgentDeployScriptResponse> generateAgentDeployScript​(GenerateAgentDeployScriptRequest request,
                                                                    AsyncHandler<GenerateAgentDeployScriptRequest,​GenerateAgentDeployScriptResponse> handler)
        Generates Agent Deploy Script for Fleet using the information provided.
        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.

      • getCryptoAnalysisResult

        Future<GetCryptoAnalysisResultResponse> getCryptoAnalysisResult​(GetCryptoAnalysisResultRequest request,
                                                                AsyncHandler<GetCryptoAnalysisResultRequest,​GetCryptoAnalysisResultResponse> handler)
        Retrieve the metadata for the result of a Crypto event analysis.
        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.

      • getDrsFile

        Future<GetDrsFileResponse> getDrsFile​(GetDrsFileRequest request,
                                      AsyncHandler<GetDrsFileRequest,​GetDrsFileResponse> handler)
        Get the detail about the created DRS file in the Fleet.
        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.

      • getExportSetting

        Future<GetExportSettingResponse> getExportSetting​(GetExportSettingRequest request,
                                                  AsyncHandler<GetExportSettingRequest,​GetExportSettingResponse> handler)
        Returns export setting for the specified fleet.
        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.

      • getExportStatus

        Future<GetExportStatusResponse> getExportStatus​(GetExportStatusRequest request,
                                                AsyncHandler<GetExportStatusRequest,​GetExportStatusResponse> handler)
        Returns last export status for the specified fleet.
        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.

      • getFleet

        Future<GetFleetResponse> getFleet​(GetFleetRequest request,
                                  AsyncHandler<GetFleetRequest,​GetFleetResponse> handler)
        Retrieve a Fleet with the specified 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.

      • getJavaFamily

        Future<GetJavaFamilyResponse> getJavaFamily​(GetJavaFamilyRequest request,
                                            AsyncHandler<GetJavaFamilyRequest,​GetJavaFamilyResponse> handler)
        Returns metadata associated with a specific Java release family.
        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.

      • getJavaRelease

        Future<GetJavaReleaseResponse> getJavaRelease​(GetJavaReleaseRequest request,
                                              AsyncHandler<GetJavaReleaseRequest,​GetJavaReleaseResponse> handler)
        Returns detail of a Java release.
        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.

      • getJmsPlugin

        Future<GetJmsPluginResponse> getJmsPlugin​(GetJmsPluginRequest request,
                                          AsyncHandler<GetJmsPluginRequest,​GetJmsPluginResponse> handler)
        Returns the JmsPlugin.
        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.

      • getTaskSchedule

        Future<GetTaskScheduleResponse> getTaskSchedule​(GetTaskScheduleRequest request,
                                                AsyncHandler<GetTaskScheduleRequest,​GetTaskScheduleResponse> handler)
        Returns a task schedule.
        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)
        Retrieve the details of a work request with the specified 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.

      • listAgentInstallers

        Future<ListAgentInstallersResponse> listAgentInstallers​(ListAgentInstallersRequest request,
                                                        AsyncHandler<ListAgentInstallersRequest,​ListAgentInstallersResponse> handler)
        Returns a list of the agent installer information.
        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.

      • listAnnouncements

        Future<ListAnnouncementsResponse> listAnnouncements​(ListAnnouncementsRequest request,
                                                    AsyncHandler<ListAnnouncementsRequest,​ListAnnouncementsResponse> handler)
        Return a list of AnnouncementSummary items
        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.

      • listBlocklists

        Future<ListBlocklistsResponse> listBlocklists​(ListBlocklistsRequest request,
                                              AsyncHandler<ListBlocklistsRequest,​ListBlocklistsResponse> handler)
        Returns a list of blocklist entities contained by a fleet.
        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.

      • listContainers

        Future<ListContainersResponse> listContainers​(ListContainersRequest request,
                                              AsyncHandler<ListContainersRequest,​ListContainersResponse> handler)
        List containers in a fleet filtered by query parameters.
        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.

      • listDrsFiles

        Future<ListDrsFilesResponse> listDrsFiles​(ListDrsFilesRequest request,
                                          AsyncHandler<ListDrsFilesRequest,​ListDrsFilesResponse> handler)
        List the details about the created DRS files in the Fleet.
        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.

      • listFleetDiagnoses

        Future<ListFleetDiagnosesResponse> listFleetDiagnoses​(ListFleetDiagnosesRequest request,
                                                      AsyncHandler<ListFleetDiagnosesRequest,​ListFleetDiagnosesResponse> handler)
        List potential diagnoses that would put a fleet into FAILED or NEEDS_ATTENTION lifecycle 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.

      • listFleetErrors

        Future<ListFleetErrorsResponse> listFleetErrors​(ListFleetErrorsRequest request,
                                                AsyncHandler<ListFleetErrorsRequest,​ListFleetErrorsResponse> handler)
        Returns a list of fleet errors that describe all detected errors.
        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.

      • listFleets

        Future<ListFleetsResponse> listFleets​(ListFleetsRequest request,
                                      AsyncHandler<ListFleetsRequest,​ListFleetsResponse> handler)
        Returns a list of all the Fleets contained by a 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.

      • listInstallationSites

        Future<ListInstallationSitesResponse> listInstallationSites​(ListInstallationSitesRequest request,
                                                            AsyncHandler<ListInstallationSitesRequest,​ListInstallationSitesResponse> handler)
        List Java installation sites in a Fleet filtered by query parameters.
        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.

      • listJavaFamilies

        Future<ListJavaFamiliesResponse> listJavaFamilies​(ListJavaFamiliesRequest request,
                                                  AsyncHandler<ListJavaFamiliesRequest,​ListJavaFamiliesResponse> handler)
        Returns a list of the Java release family information.

        A Java release family is typically a major version in the Java version 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.

      • listJavaReleases

        Future<ListJavaReleasesResponse> listJavaReleases​(ListJavaReleasesRequest request,
                                                  AsyncHandler<ListJavaReleasesRequest,​ListJavaReleasesResponse> handler)
        Returns a list of Java releases.
        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.

      • listJmsPlugins

        Future<ListJmsPluginsResponse> listJmsPlugins​(ListJmsPluginsRequest request,
                                              AsyncHandler<ListJmsPluginsRequest,​ListJmsPluginsResponse> handler)
        Lists the JmsPlugins.
        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.

      • listJreUsage

        Future<ListJreUsageResponse> listJreUsage​(ListJreUsageRequest request,
                                          AsyncHandler<ListJreUsageRequest,​ListJreUsageResponse> handler)
        List Java Runtime usage in a specified host filtered by query parameters.
        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.

      • listPluginErrors

        Future<ListPluginErrorsResponse> listPluginErrors​(ListPluginErrorsRequest request,
                                                  AsyncHandler<ListPluginErrorsRequest,​ListPluginErrorsResponse> handler)
        Returns a list of plugin errors that describe all detected errors.
        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.

      • listTaskSchedules

        Future<ListTaskSchedulesResponse> listTaskSchedules​(ListTaskSchedulesRequest request,
                                                    AsyncHandler<ListTaskSchedulesRequest,​ListTaskSchedulesResponse> handler)
        Returns a list of task schedules.
        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.

      • listUncorrelatedPackageUsage

        Future<ListUncorrelatedPackageUsageResponse> listUncorrelatedPackageUsage​(ListUncorrelatedPackageUsageRequest request,
                                                                          AsyncHandler<ListUncorrelatedPackageUsageRequest,​ListUncorrelatedPackageUsageResponse> handler)
        List uncorrelated package summaries in a fleet, filtered by query parameters.

        Uncorrelated packages are Java packages which can’t be accurately correlated to a library during a library scan.

        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.

      • listWorkItems

        Future<ListWorkItemsResponse> listWorkItems​(ListWorkItemsRequest request,
                                            AsyncHandler<ListWorkItemsRequest,​ListWorkItemsResponse> handler)
        Retrieve a paginated list of work items for a specified 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.

      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                            AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Retrieve a (paginated) list of errors for a specified 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)
        Retrieve a paginated list of logs for a specified 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)
        List the work requests in a compartment.

        The query parameter compartmentId is required unless the query parameter id or fleetId 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.

      • requestCryptoAnalyses

        Future<RequestCryptoAnalysesResponse> requestCryptoAnalyses​(RequestCryptoAnalysesRequest request,
                                                            AsyncHandler<RequestCryptoAnalysesRequest,​RequestCryptoAnalysesResponse> handler)
        Request to perform crypto analysis on one or more selected targets in the Fleet.

        The result of the crypto analysis will be uploaded to the object storage bucket created by JMS on enabling the Crypto Event Analysis feature in the Fleet.

        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.

      • requestJavaMigrationAnalyses

        Future<RequestJavaMigrationAnalysesResponse> requestJavaMigrationAnalyses​(RequestJavaMigrationAnalysesRequest request,
                                                                          AsyncHandler<RequestJavaMigrationAnalysesRequest,​RequestJavaMigrationAnalysesResponse> handler)
        Request to perform a Java migration analysis.

        The results of the Java migration analysis will be uploaded to the Object Storage bucket that you designate when you enable the Java Migration Analysis feature.

        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.

      • requestJfrRecordings

        Future<RequestJfrRecordingsResponse> requestJfrRecordings​(RequestJfrRecordingsRequest request,
                                                          AsyncHandler<RequestJfrRecordingsRequest,​RequestJfrRecordingsResponse> handler)
        Request to collect the JFR recordings on the selected target in the Fleet.

        The JFR files are uploaded to the object storage bucket created by JMS on enabling Generic JFR feature in the Fleet.

        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.

      • requestPerformanceTuningAnalyses

        Future<RequestPerformanceTuningAnalysesResponse> requestPerformanceTuningAnalyses​(RequestPerformanceTuningAnalysesRequest request,
                                                                                  AsyncHandler<RequestPerformanceTuningAnalysesRequest,​RequestPerformanceTuningAnalysesResponse> handler)
        Request to perform performance tuning analyses.

        The result of performance tuning analysis will be uploaded to the object storage bucket that you designated when you enabled the recording feature.

        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.

      • scanJavaServerUsage

        Future<ScanJavaServerUsageResponse> scanJavaServerUsage​(ScanJavaServerUsageRequest request,
                                                        AsyncHandler<ScanJavaServerUsageRequest,​ScanJavaServerUsageResponse> handler)
        Scan Java Server usage in a fleet.
        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.

      • scanLibraryUsage

        Future<ScanLibraryUsageResponse> scanLibraryUsage​(ScanLibraryUsageRequest request,
                                                  AsyncHandler<ScanLibraryUsageRequest,​ScanLibraryUsageResponse> handler)
        Scan library usage in a fleet.
        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.

      • summarizeApplicationInstallationUsage

        Future<SummarizeApplicationInstallationUsageResponse> summarizeApplicationInstallationUsage​(SummarizeApplicationInstallationUsageRequest request,
                                                                                            AsyncHandler<SummarizeApplicationInstallationUsageRequest,​SummarizeApplicationInstallationUsageResponse> handler)
        Summarizes the application installation usage in a Fleet filtered by query parameters.

        In contrast to SummarizeApplicationUsage, which provides only information aggregated by application name, this operation provides installation details. This allows for better focusing of actions.

        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.

      • summarizeFleetErrors

        Future<SummarizeFleetErrorsResponse> summarizeFleetErrors​(SummarizeFleetErrorsRequest request,
                                                          AsyncHandler<SummarizeFleetErrorsRequest,​SummarizeFleetErrorsResponse> handler)
        Returns a high level summary of FleetErrors.
        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.

      • summarizeJavaServerUsage

        Future<SummarizeJavaServerUsageResponse> summarizeJavaServerUsage​(SummarizeJavaServerUsageRequest request,
                                                                  AsyncHandler<SummarizeJavaServerUsageRequest,​SummarizeJavaServerUsageResponse> handler)
        List of Java servers in a Fleet filtered by query parameters.
        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.

      • summarizeJreUsage

        Future<SummarizeJreUsageResponse> summarizeJreUsage​(SummarizeJreUsageRequest request,
                                                    AsyncHandler<SummarizeJreUsageRequest,​SummarizeJreUsageResponse> handler)
        List Java Runtime usage in a specified Fleet filtered by query parameters.
        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.

      • summarizeLibraryInventory

        Future<SummarizeLibraryInventoryResponse> summarizeLibraryInventory​(SummarizeLibraryInventoryRequest request,
                                                                    AsyncHandler<SummarizeLibraryInventoryRequest,​SummarizeLibraryInventoryResponse> handler)
        Retrieve the inventory of libraries in the specified fleet: Statically detected library count, Dynamically detected library count, Uncorrelated package count, High, Medium and Low severity library count.
        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.

      • summarizeLibraryUsage

        Future<SummarizeLibraryUsageResponse> summarizeLibraryUsage​(SummarizeLibraryUsageRequest request,
                                                            AsyncHandler<SummarizeLibraryUsageRequest,​SummarizeLibraryUsageResponse> handler)
        List libraries in a fleet filtered by query parameters.
        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.

      • summarizePluginErrors

        Future<SummarizePluginErrorsResponse> summarizePluginErrors​(SummarizePluginErrorsRequest request,
                                                            AsyncHandler<SummarizePluginErrorsRequest,​SummarizePluginErrorsResponse> handler)
        Returns a high level summary of PluginErrors.
        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.

      • summarizeResourceInventory

        Future<SummarizeResourceInventoryResponse> summarizeResourceInventory​(SummarizeResourceInventoryRequest request,
                                                                      AsyncHandler<SummarizeResourceInventoryRequest,​SummarizeResourceInventoryResponse> handler)
        Retrieve the inventory of JMS resources in the specified compartment: a list of the number of active fleets, managed instances, Java Runtimes, Java installations, and 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.

      • updateDrsFile

        Future<UpdateDrsFileResponse> updateDrsFile​(UpdateDrsFileRequest request,
                                            AsyncHandler<UpdateDrsFileRequest,​UpdateDrsFileResponse> handler)
        Request to perform validation of the DRS file and update the existing file in the Object Storage.
        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.

      • updateExportSetting

        Future<UpdateExportSettingResponse> updateExportSetting​(UpdateExportSettingRequest request,
                                                        AsyncHandler<UpdateExportSettingRequest,​UpdateExportSettingResponse> handler)
        Updates existing export setting for the specified fleet.
        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.

      • updateFleet

        Future<UpdateFleetResponse> updateFleet​(UpdateFleetRequest request,
                                        AsyncHandler<UpdateFleetRequest,​UpdateFleetResponse> handler)
        Update the Fleet 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.

      • updateJmsPlugin

        Future<UpdateJmsPluginResponse> updateJmsPlugin​(UpdateJmsPluginRequest request,
                                                AsyncHandler<UpdateJmsPluginRequest,​UpdateJmsPluginResponse> handler)
        Updates the Fleet of a JmsPlugin.
        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.

      • updateTaskSchedule

        Future<UpdateTaskScheduleResponse> updateTaskSchedule​(UpdateTaskScheduleRequest request,
                                                      AsyncHandler<UpdateTaskScheduleRequest,​UpdateTaskScheduleResponse> handler)
        Update the task schedule for the given task type.
        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.