Package com.oracle.bmc.vulnerabilityscanning

Interface VulnerabilityScanningAsync

    • 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

      • createContainerScanRecipe

        Future<CreateContainerScanRecipeResponse> createContainerScanRecipe​(CreateContainerScanRecipeRequest request,
                                                                    AsyncHandler<CreateContainerScanRecipeRequest,​CreateContainerScanRecipeResponse> handler)
        Creates a new ContainerScanRecipe.

        A recipe determines the types of security issues that you want scanned.

        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.

      • createContainerScanTarget

        Future<CreateContainerScanTargetResponse> createContainerScanTarget​(CreateContainerScanTargetRequest request,
                                                                    AsyncHandler<CreateContainerScanTargetRequest,​CreateContainerScanTargetResponse> handler)
        Creates a new ContainerScanTarget.

        A container scan target specifies a group of one or more Docker image repositories in Oracle Cloud Infrastructure Registry (OCIR) that you want routinely scanned for security vulnerabilities.

        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.

      • createHostScanRecipe

        Future<CreateHostScanRecipeResponse> createHostScanRecipe​(CreateHostScanRecipeRequest request,
                                                          AsyncHandler<CreateHostScanRecipeRequest,​CreateHostScanRecipeResponse> handler)
        Creates a new HostScanRecipe.

        A recipe determines the types of security issues that you want scanned, and how often to 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.

      • createHostScanTarget

        Future<CreateHostScanTargetResponse> createHostScanTarget​(CreateHostScanTargetRequest request,
                                                          AsyncHandler<CreateHostScanTargetRequest,​CreateHostScanTargetResponse> handler)
        Creates a new HostScanTarget.

        A host scan target is a collection of compute instances that you want routinely scanned for security vulnerabilities.

        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.

      • deleteHostPortScanResult

        Future<DeleteHostPortScanResultResponse> deleteHostPortScanResult​(DeleteHostPortScanResultRequest request,
                                                                  AsyncHandler<DeleteHostPortScanResultRequest,​DeleteHostPortScanResultResponse> handler)
        Deletes the HostPortScanResult identified by the host port scan 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.

      • deleteHostScanRecipe

        Future<DeleteHostScanRecipeResponse> deleteHostScanRecipe​(DeleteHostScanRecipeRequest request,
                                                          AsyncHandler<DeleteHostScanRecipeRequest,​DeleteHostScanRecipeResponse> handler)
        Deletes the HostScanRecipe identified by the recipe 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.

      • deleteHostScanTarget

        Future<DeleteHostScanTargetResponse> deleteHostScanTarget​(DeleteHostScanTargetRequest request,
                                                          AsyncHandler<DeleteHostScanTargetRequest,​DeleteHostScanTargetResponse> handler)
        Deletes the HostScanTarget identified by the target 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.

      • exportHostAgentScanResultCsv

        Future<ExportHostAgentScanResultCsvResponse> exportHostAgentScanResultCsv​(ExportHostAgentScanResultCsvRequest request,
                                                                          AsyncHandler<ExportHostAgentScanResultCsvRequest,​ExportHostAgentScanResultCsvResponse> handler)
        Exports a list of HostAgentScanResultSummary objects within a compartment and during a specified time range in CSV format.

        You can filter the results by problem severity.

        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.

      • getContainerScanRecipe

        Future<GetContainerScanRecipeResponse> getContainerScanRecipe​(GetContainerScanRecipeRequest request,
                                                              AsyncHandler<GetContainerScanRecipeRequest,​GetContainerScanRecipeResponse> handler)
        Retrieves a ContainerScanRecipe identified by the recipe ID.

        A recipe determines the types of security issues that you want scanned.

        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.

      • getContainerScanResult

        Future<GetContainerScanResultResponse> getContainerScanResult​(GetContainerScanResultRequest request,
                                                              AsyncHandler<GetContainerScanResultRequest,​GetContainerScanResultResponse> handler)
        Retrieves a ContainerScanResult identified by the container scan ID.

        The result includes a list of problems found in a specific image in a Docker repository.

        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.

      • getContainerScanTarget

        Future<GetContainerScanTargetResponse> getContainerScanTarget​(GetContainerScanTargetRequest request,
                                                              AsyncHandler<GetContainerScanTargetRequest,​GetContainerScanTargetResponse> handler)
        Gets a ContainerScanTarget identified by the target ID.

        A container scan target specifies a group of one or more Docker image repositories in Oracle Cloud Infrastructure Registry (OCIR) that you want routinely scanned for security vulnerabilities.

        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.

      • getHostAgentScanResult

        Future<GetHostAgentScanResultResponse> getHostAgentScanResult​(GetHostAgentScanResultRequest request,
                                                              AsyncHandler<GetHostAgentScanResultRequest,​GetHostAgentScanResultResponse> handler)
        Retrieves a HostAgentScanResult identified by the host agent scan ID.

        The result includes a list of CVEs detected in a specific compute instance.

        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.

      • getHostCisBenchmarkScanResult

        Future<GetHostCisBenchmarkScanResultResponse> getHostCisBenchmarkScanResult​(GetHostCisBenchmarkScanResultRequest request,
                                                                            AsyncHandler<GetHostCisBenchmarkScanResultRequest,​GetHostCisBenchmarkScanResultResponse> handler)
        Retrieves a HostCisBenchmarkScanResult identified by the benchmark scan result ID.

        A CIS (Center for Internet Security) benchmark scan result includes a list of benchmarks that were tested on a specific compute instance, and whether each test passed or failed.

        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.

      • getHostPortScanResult

        Future<GetHostPortScanResultResponse> getHostPortScanResult​(GetHostPortScanResultRequest request,
                                                            AsyncHandler<GetHostPortScanResultRequest,​GetHostPortScanResultResponse> handler)
        Retrieves a HostPortScanResult identified by the host port scan ID.

        The result includes a list of open ports that were detected in a specific compute instance.

        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.

      • getHostScanRecipe

        Future<GetHostScanRecipeResponse> getHostScanRecipe​(GetHostScanRecipeRequest request,
                                                    AsyncHandler<GetHostScanRecipeRequest,​GetHostScanRecipeResponse> handler)
        Retrieves a HostScanRecipe identified by the recipe ID.

        A recipe determines the types of security issues that you want scanned, and how often to 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.

      • getHostScanTarget

        Future<GetHostScanTargetResponse> getHostScanTarget​(GetHostScanTargetRequest request,
                                                    AsyncHandler<GetHostScanTargetRequest,​GetHostScanTargetResponse> handler)
        Retrieves a HostScanTarget identified by the target ID.

        A host scan target is a collection of compute instances that you want routinely scanned for security vulnerabilities.

        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.

      • getHostVulnerability

        Future<GetHostVulnerabilityResponse> getHostVulnerability​(GetHostVulnerabilityRequest request,
                                                          AsyncHandler<GetHostVulnerabilityRequest,​GetHostVulnerabilityResponse> handler)
        Retrieves a HostVulnerability identified by the host vulnerability ID.

        A host vulnerability describes a security issue that was detected in scans of one or more compute instances. Common Vulnerabilities and Exposures (CVE) numbers identify security vulnerabilities for operating systems and other software, including Critical Patch Updates and Security Alert advisories.

        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.

      • getVulnerability

        Future<GetVulnerabilityResponse> getVulnerability​(GetVulnerabilityRequest request,
                                                  AsyncHandler<GetVulnerabilityRequest,​GetVulnerabilityResponse> handler)
        Retrieves a Vulnerability identified by the vulnerability ID.

        A vulnerability describes a security issue that was detected in scans of one or more compute instances, container scan repositories. Common Vulnerabilities and Exposures (CVE) numbers identify security vulnerabilities for operating systems and other software, including Critical Patch Updates and Security Alert advisories.

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

      • getWorkRequest

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                              AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets the status of the work request with the given 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.

      • listContainerScanRecipes

        Future<ListContainerScanRecipesResponse> listContainerScanRecipes​(ListContainerScanRecipesRequest request,
                                                                  AsyncHandler<ListContainerScanRecipesRequest,​ListContainerScanRecipesResponse> handler)
        Retrieves a list of ContainerScanRecipeSummary objects in a compartment.

        A recipe determines the types of security issues that you want scanned.

        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.

      • listContainerScanResults

        Future<ListContainerScanResultsResponse> listContainerScanResults​(ListContainerScanResultsRequest request,
                                                                  AsyncHandler<ListContainerScanResultsRequest,​ListContainerScanResultsResponse> handler)
        Retrieves a list of ContainerScanResultSummary objects in a compartment.

        You can filter and sort the results by problem severity and time. A container scan result includes a list of problems detected in a specific image in a Docker repository.

        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.

      • listContainerScanTargets

        Future<ListContainerScanTargetsResponse> listContainerScanTargets​(ListContainerScanTargetsRequest request,
                                                                  AsyncHandler<ListContainerScanTargetsRequest,​ListContainerScanTargetsResponse> handler)
        Retrieves a list of ContainerScanTargetSummary objects in a compartment.

        A container scan target specifies a group of one or more Docker image repositories in Oracle Cloud Infrastructure Registry (OCIR) that you want routinely scanned for security vulnerabilities.

        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.

      • listHostAgentScanResults

        Future<ListHostAgentScanResultsResponse> listHostAgentScanResults​(ListHostAgentScanResultsRequest request,
                                                                  AsyncHandler<ListHostAgentScanResultsRequest,​ListHostAgentScanResultsResponse> handler)
        Retrieves a list of HostAgentScanResultSummary objects in a compartment.

        You can filter and sort the results by problem severity and time. An agent scan result includes a list of CVEs detected in a specific compute instance.

        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.

      • listHostCisBenchmarkScanResults

        Future<ListHostCisBenchmarkScanResultsResponse> listHostCisBenchmarkScanResults​(ListHostCisBenchmarkScanResultsRequest request,
                                                                                AsyncHandler<ListHostCisBenchmarkScanResultsRequest,​ListHostCisBenchmarkScanResultsResponse> handler)
        Retrieves a list of HostCisBenchmarkScanResultSummary objects in a compartment.

        You can filter and sort the results by problem severity and time. A CIS (Center for Internet Security) benchmark scan result includes the number of failed benchmark tests on a specific compute instance.

        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.

      • listHostPortScanResults

        Future<ListHostPortScanResultsResponse> listHostPortScanResults​(ListHostPortScanResultsRequest request,
                                                                AsyncHandler<ListHostPortScanResultsRequest,​ListHostPortScanResultsResponse> handler)
        Retrieves a list of HostPortScanResultSummary objects in a compartment.

        You can filter and sort the results by problem severity and time. A port scan result includes a list of open ports that were detected in a specific compute instance.

        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.

      • listHostScanRecipes

        Future<ListHostScanRecipesResponse> listHostScanRecipes​(ListHostScanRecipesRequest request,
                                                        AsyncHandler<ListHostScanRecipesRequest,​ListHostScanRecipesResponse> handler)
        Retrieves a list of HostScanRecipeSummary objects in a compartment.

        A recipe determines the types of security issues that you want scanned, and how often to 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.

      • listHostScanTargetErrors

        Future<ListHostScanTargetErrorsResponse> listHostScanTargetErrors​(ListHostScanTargetErrorsRequest request,
                                                                  AsyncHandler<ListHostScanTargetErrorsRequest,​ListHostScanTargetErrorsResponse> handler)
        Retrieves list of errors during scanning on instances associated with HostScanTarget identified by the target ID.

        A host scan target is a collection of compute instances that you want routinely scanned for security vulnerabilities.

        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.

      • listHostScanTargets

        Future<ListHostScanTargetsResponse> listHostScanTargets​(ListHostScanTargetsRequest request,
                                                        AsyncHandler<ListHostScanTargetsRequest,​ListHostScanTargetsResponse> handler)
        Retrieves a list of HostScanTargetSummary objects in a compartment.

        A host scan target is a collection of compute instances that you want routinely scanned for security vulnerabilities.

        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.

      • listHostVulnerabilities

        Future<ListHostVulnerabilitiesResponse> listHostVulnerabilities​(ListHostVulnerabilitiesRequest request,
                                                                AsyncHandler<ListHostVulnerabilitiesRequest,​ListHostVulnerabilitiesResponse> handler)
        Retrieves a list of HostVulnerabilitySummary objects in a compartment.

        You can filter and sort the vulnerabilities by problem severity and time. A host vulnerability describes a security issue that was detected in scans of one or more compute instances.

        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.

      • listHostVulnerabilityImpactedHosts

        Future<ListHostVulnerabilityImpactedHostsResponse> listHostVulnerabilityImpactedHosts​(ListHostVulnerabilityImpactedHostsRequest request,
                                                                                      AsyncHandler<ListHostVulnerabilityImpactedHostsRequest,​ListHostVulnerabilityImpactedHostsResponse> handler)
        Retrieves a list of HostVulnerabilityImpactedHostSummary objects for a specific host vulnerability ID.

        An impacted host summary identifies a compute instance on which the specified vulnerability was detected.

        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.

      • listVulnerabilities

        Future<ListVulnerabilitiesResponse> listVulnerabilities​(ListVulnerabilitiesRequest request,
                                                        AsyncHandler<ListVulnerabilitiesRequest,​ListVulnerabilitiesResponse> handler)
        Retrieves a list of VulnerabilitySummary objects in a compartment.

        You can filter and sort the vulnerabilities by problem severity and time and type. A vulnerability describes a security issue that was detected in scans of one or more compute instances, container images.

        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.

      • listVulnerabilityImpactedContainers

        Future<ListVulnerabilityImpactedContainersResponse> listVulnerabilityImpactedContainers​(ListVulnerabilityImpactedContainersRequest request,
                                                                                        AsyncHandler<ListVulnerabilityImpactedContainersRequest,​ListVulnerabilityImpactedContainersResponse> handler)
        Retrieves a list of VulnerabilityImpactedContainerSummary objects for a specific vulnerability ID.

        An impacted container image summary identifies container images on which the specified vulnerability was detected.

        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.

      • listVulnerabilityImpactedHosts

        Future<ListVulnerabilityImpactedHostsResponse> listVulnerabilityImpactedHosts​(ListVulnerabilityImpactedHostsRequest request,
                                                                              AsyncHandler<ListVulnerabilityImpactedHostsRequest,​ListVulnerabilityImpactedHostsResponse> handler)
        Retrieves a list of VulnerabilityImpactedHostSummary objects for a specific host vulnerability ID.

        An impacted host summary identifies a compute instance on which the specified vulnerability was detected.

        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)
        Return a (paginated) list of errors for a given 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)
        Return a (paginated) list of logs for a given 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)
        Lists the work requests in a 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.

      • updateContainerScanRecipe

        Future<UpdateContainerScanRecipeResponse> updateContainerScanRecipe​(UpdateContainerScanRecipeRequest request,
                                                                    AsyncHandler<UpdateContainerScanRecipeRequest,​UpdateContainerScanRecipeResponse> handler)
        Updates the ContainerScanRecipe identified by the recipe ID.

        A recipe determines the types of security issues that you want scanned.

        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.

      • updateContainerScanTarget

        Future<UpdateContainerScanTargetResponse> updateContainerScanTarget​(UpdateContainerScanTargetRequest request,
                                                                    AsyncHandler<UpdateContainerScanTargetRequest,​UpdateContainerScanTargetResponse> handler)
        Updates the ContainerScanTarget identified by the target ID.

        A container scan target specifies a group of one or more Docker image repositories in Oracle Cloud Infrastructure Registry (OCIR) that you want routinely scanned for security vulnerabilities.

        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.

      • updateHostScanRecipe

        Future<UpdateHostScanRecipeResponse> updateHostScanRecipe​(UpdateHostScanRecipeRequest request,
                                                          AsyncHandler<UpdateHostScanRecipeRequest,​UpdateHostScanRecipeResponse> handler)
        Updates the HostScanRecipe identified by the recipe ID.

        A recipe determines the types of security issues that you want scanned, and how often to 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.

      • updateHostScanTarget

        Future<UpdateHostScanTargetResponse> updateHostScanTarget​(UpdateHostScanTargetRequest request,
                                                          AsyncHandler<UpdateHostScanTargetRequest,​UpdateHostScanTargetResponse> handler)
        Updates the HostScanTarget identified by the target ID.

        A host scan target is a collection of compute instances that you want routinely scanned for security vulnerabilities.

        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.