Class CloudGuardAsyncClient

  • All Implemented Interfaces:
    CloudGuardAsync, AutoCloseable

    @Generated(value="OracleSDKGenerator",
               comments="API Version: 20200131")
    public class CloudGuardAsyncClient
    extends BaseAsyncClient
    implements CloudGuardAsync
    Async client implementation for CloudGuard service.
    There are two ways to use async client: 1. Use AsyncHandler: using AsyncHandler, if the response to the call is an InputStream, like getObject Api in object storage service, developers need to process the stream in AsyncHandler, and not anywhere else, because the stream will be closed right after the AsyncHandler is invoked.
    2. Use Java Future: using Java Future, developers need to close the stream after they are done with the Java Future.
    Accessing the result should be done in a mutually exclusive manner, either through the Future or the AsyncHandler, but not both. If the Future is used, the caller should pass in null as the AsyncHandler. If the AsyncHandler is used, it is still safe to use the Future to determine whether or not the request was completed via Future.isDone/isCancelled.
    Please refer to https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/ResteasyClientWithObjectStorageExample.java
    • Field Detail

      • SERVICE

        public static final Service SERVICE
        Service instance for CloudGuard.
      • clientCommonLibraryVersion

        public final String clientCommonLibraryVersion
        Compatible SDK version, provided by the codegen.
      • minimumClientCommonLibraryVersionFromClient

        public final Optional<String> minimumClientCommonLibraryVersionFromClient
        Minimum compatible SDK version, maybe provided by the codegen.
    • Method Detail

      • setRegion

        public void setRegion​(Region region)
        Description copied from interface: CloudGuardAsync
        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.

        Specified by:
        setRegion in interface CloudGuardAsync
        Parameters:
        region - The region of the service.
      • addCompartment

        public Future<AddCompartmentResponse> addCompartment​(AddCompartmentRequest request,
                                                             AsyncHandler<AddCompartmentRequest,​AddCompartmentResponse> handler)
        Description copied from interface: CloudGuardAsync
        Adds a compartment to an existing security zone (SecurityZone resource), identified by securityZoneId.

        Specify parameters in an AddCompartmentDetails resource that you pass. If you previously removed a subcompartment from a security zone, you can add it back to the same security zone. The security zone ensures that resources in the subcompartment comply with the security zone’s policies.

        Specified by:
        addCompartment in interface CloudGuardAsync
        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.
      • createDataSource

        public Future<CreateDataSourceResponse> createDataSource​(CreateDataSourceRequest request,
                                                                 AsyncHandler<CreateDataSourceRequest,​CreateDataSourceResponse> handler)
        Description copied from interface: CloudGuardAsync
        Creates a data source (DataSource resource), using parameters passed through a CreateDataSourceDetails resource.
        Specified by:
        createDataSource in interface CloudGuardAsync
        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.
      • createSecurityZone

        public Future<CreateSecurityZoneResponse> createSecurityZone​(CreateSecurityZoneRequest request,
                                                                     AsyncHandler<CreateSecurityZoneRequest,​CreateSecurityZoneResponse> handler)
        Description copied from interface: CloudGuardAsync
        Creates a security zone (SecurityZone resource) for a compartment.

        Pass parameters through a CreateSecurityZoneDetails resource.

        Specified by:
        createSecurityZone in interface CloudGuardAsync
        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.
      • createTarget

        public Future<CreateTargetResponse> createTarget​(CreateTargetRequest request,
                                                         AsyncHandler<CreateTargetRequest,​CreateTargetResponse> handler)
        Description copied from interface: CloudGuardAsync
        Creates a target (Target resource), using parameters passed in a CreateTargetDetails resource.
        Specified by:
        createTarget in interface CloudGuardAsync
        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.
      • createWlpAgent

        public Future<CreateWlpAgentResponse> createWlpAgent​(CreateWlpAgentRequest request,
                                                             AsyncHandler<CreateWlpAgentRequest,​CreateWlpAgentResponse> handler)
        Description copied from interface: CloudGuardAsync
        Creates and registers a WLP agent for an on-premise resource.
        Specified by:
        createWlpAgent in interface CloudGuardAsync
        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.
      • deleteAdhocQuery

        public Future<DeleteAdhocQueryResponse> deleteAdhocQuery​(DeleteAdhocQueryRequest request,
                                                                 AsyncHandler<DeleteAdhocQueryRequest,​DeleteAdhocQueryResponse> handler)
        Description copied from interface: CloudGuardAsync
        Deletes a AdhocQuery resource identified by adhocQueryId.
        Specified by:
        deleteAdhocQuery in interface CloudGuardAsync
        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.
      • deleteDataSource

        public Future<DeleteDataSourceResponse> deleteDataSource​(DeleteDataSourceRequest request,
                                                                 AsyncHandler<DeleteDataSourceRequest,​DeleteDataSourceResponse> handler)
        Description copied from interface: CloudGuardAsync
        Deletes a data source (DataSource resource) identified by dataSourceId.
        Specified by:
        deleteDataSource in interface CloudGuardAsync
        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.
      • deleteSavedQuery

        public Future<DeleteSavedQueryResponse> deleteSavedQuery​(DeleteSavedQueryRequest request,
                                                                 AsyncHandler<DeleteSavedQueryRequest,​DeleteSavedQueryResponse> handler)
        Description copied from interface: CloudGuardAsync
        Deletes a SavedQuery resource identified by savedQueryId.
        Specified by:
        deleteSavedQuery in interface CloudGuardAsync
        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.
      • deleteSecurityRecipe

        public Future<DeleteSecurityRecipeResponse> deleteSecurityRecipe​(DeleteSecurityRecipeRequest request,
                                                                         AsyncHandler<DeleteSecurityRecipeRequest,​DeleteSecurityRecipeResponse> handler)
        Description copied from interface: CloudGuardAsync
        Deletes a security zone recipe, identified by securityRecipeId.

        The recipe can’t be associated with an existing security zone.

        Specified by:
        deleteSecurityRecipe in interface CloudGuardAsync
        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.
      • deleteTarget

        public Future<DeleteTargetResponse> deleteTarget​(DeleteTargetRequest request,
                                                         AsyncHandler<DeleteTargetRequest,​DeleteTargetResponse> handler)
        Description copied from interface: CloudGuardAsync
        Deletes a target (Target resource) identified by targetId.
        Specified by:
        deleteTarget in interface CloudGuardAsync
        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.
      • deleteWlpAgent

        public Future<DeleteWlpAgentResponse> deleteWlpAgent​(DeleteWlpAgentRequest request,
                                                             AsyncHandler<DeleteWlpAgentRequest,​DeleteWlpAgentResponse> handler)
        Description copied from interface: CloudGuardAsync
        Deletes and unregisters the WLP agent for an on-premise resource.

        x-obmcs-splat: routing: strategy: route-to-any-ad serviceList: [ ‘cloudguard-cp-SPLAT_ENV’ ] resources: wlpAgent: serviceResourceName: WlpAgent targetCompartmentId: downstream.getOr404(‘cloudguard-cp-SPLAT_ENV’, ‘GetWlpAgent’, request.resourceId).compartmentId actionKind: delete resourceOcid: request.resourceId reconciliationCanStartAfterSecs: 30 permissions: [ "WLP_AGENT_DELETE" ] authorization: mode: automated check: resources[‘wlpAgent’].grantedPermissions.contains(‘WLP_AGENT_DELETE’) allowCrossTenancy: true tagStore: mode: automated maximumAttemptCount: 3 throttling: perUserLimit: rpsLimit: 15 perTenantLimit: rpsLimit: 30 quotas: mode: automated search: mode: backfilling operationResourceName: wlpAgent lock: mode: test operationResourceName: wlpAgent

        Specified by:
        deleteWlpAgent in interface CloudGuardAsync
        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.
      • getAdhocQuery

        public Future<GetAdhocQueryResponse> getAdhocQuery​(GetAdhocQueryRequest request,
                                                           AsyncHandler<GetAdhocQueryRequest,​GetAdhocQueryResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns an adhoc query identified by adhocQueryId.
        Specified by:
        getAdhocQuery in interface CloudGuardAsync
        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.
      • getConfiguration

        public Future<GetConfigurationResponse> getConfiguration​(GetConfigurationRequest request,
                                                                 AsyncHandler<GetConfigurationRequest,​GetConfigurationResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns the configuration details for a Cloud Guard tenancy, identified by root compartment OCID.
        Specified by:
        getConfiguration in interface CloudGuardAsync
        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.
      • getDataMaskRule

        public Future<GetDataMaskRuleResponse> getDataMaskRule​(GetDataMaskRuleRequest request,
                                                               AsyncHandler<GetDataMaskRuleRequest,​GetDataMaskRuleResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a DataMaskRule resource, identified by dataMaskRuleId.
        Specified by:
        getDataMaskRule in interface CloudGuardAsync
        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.
      • getDataSource

        public Future<GetDataSourceResponse> getDataSource​(GetDataSourceRequest request,
                                                           AsyncHandler<GetDataSourceRequest,​GetDataSourceResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a data source (DataSource resource) identified by dataSourceId.
        Specified by:
        getDataSource in interface CloudGuardAsync
        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.
      • getDetector

        public Future<GetDetectorResponse> getDetector​(GetDetectorRequest request,
                                                       AsyncHandler<GetDetectorRequest,​GetDetectorResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a Detector resource, identified by detectorId.
        Specified by:
        getDetector in interface CloudGuardAsync
        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.
      • getDetectorRecipe

        public Future<GetDetectorRecipeResponse> getDetectorRecipe​(GetDetectorRecipeRequest request,
                                                                   AsyncHandler<GetDetectorRecipeRequest,​GetDetectorRecipeResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a detector recipe (DetectorRecipe resource) identified by detectorRecipeId.
        Specified by:
        getDetectorRecipe in interface CloudGuardAsync
        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.
      • getDetectorRule

        public Future<GetDetectorRuleResponse> getDetectorRule​(GetDetectorRuleRequest request,
                                                               AsyncHandler<GetDetectorRuleRequest,​GetDetectorRuleResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a detector rule (DetectorRule resource) identified by detectorRuleId.
        Specified by:
        getDetectorRule in interface CloudGuardAsync
        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.
      • getManagedList

        public Future<GetManagedListResponse> getManagedList​(GetManagedListRequest request,
                                                             AsyncHandler<GetManagedListRequest,​GetManagedListResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a managed list identified by managedListId.
        Specified by:
        getManagedList in interface CloudGuardAsync
        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.
      • getProblem

        public Future<GetProblemResponse> getProblem​(GetProblemRequest request,
                                                     AsyncHandler<GetProblemRequest,​GetProblemResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns the Problem resource identified by problemId.
        Specified by:
        getProblem in interface CloudGuardAsync
        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.
      • getResource

        public Future<GetResourceResponse> getResource​(GetResourceRequest request,
                                                       AsyncHandler<GetResourceRequest,​GetResourceResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a resource identified by resourceId
        Specified by:
        getResource in interface CloudGuardAsync
        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.
      • getResponderRule

        public Future<GetResponderRuleResponse> getResponderRule​(GetResponderRuleRequest request,
                                                                 AsyncHandler<GetResponderRuleRequest,​GetResponderRuleResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a responder rule (ResponderRule resource) identified by resonderRuleId.
        Specified by:
        getResponderRule in interface CloudGuardAsync
        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.
      • getSavedQuery

        public Future<GetSavedQueryResponse> getSavedQuery​(GetSavedQueryRequest request,
                                                           AsyncHandler<GetSavedQueryRequest,​GetSavedQueryResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a SavedQuery resource identified by savedQueryId.
        Specified by:
        getSavedQuery in interface CloudGuardAsync
        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.
      • getSecurityPolicy

        public Future<GetSecurityPolicyResponse> getSecurityPolicy​(GetSecurityPolicyRequest request,
                                                                   AsyncHandler<GetSecurityPolicyRequest,​GetSecurityPolicyResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a security zone policy (SecurityPolicy resource), identified by its unique ID (securityPolicyId).

        When a policy is enabled in a security zone, then any action in the zone that attempts to violate that policy is blocked.

        Specified by:
        getSecurityPolicy in interface CloudGuardAsync
        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.
      • getSecurityRecipe

        public Future<GetSecurityRecipeResponse> getSecurityRecipe​(GetSecurityRecipeRequest request,
                                                                   AsyncHandler<GetSecurityRecipeRequest,​GetSecurityRecipeResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a security zone recipe (SecurityRecipe resource) identified by securityRecipeId.
        Specified by:
        getSecurityRecipe in interface CloudGuardAsync
        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.
      • getSecurityZone

        public Future<GetSecurityZoneResponse> getSecurityZone​(GetSecurityZoneRequest request,
                                                               AsyncHandler<GetSecurityZoneRequest,​GetSecurityZoneResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a security zone (SecurityZone resource) identified by securityZoneId.
        Specified by:
        getSecurityZone in interface CloudGuardAsync
        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.
      • getSighting

        public Future<GetSightingResponse> getSighting​(GetSightingRequest request,
                                                       AsyncHandler<GetSightingRequest,​GetSightingResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a single sighting (Sighting resource) identified by sightingId.
        Specified by:
        getSighting in interface CloudGuardAsync
        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.
      • getTarget

        public Future<GetTargetResponse> getTarget​(GetTargetRequest request,
                                                   AsyncHandler<GetTargetRequest,​GetTargetResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a target (Target resource) identified by targetId.
        Specified by:
        getTarget in interface CloudGuardAsync
        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.
      • getWlpAgent

        public Future<GetWlpAgentResponse> getWlpAgent​(GetWlpAgentRequest request,
                                                       AsyncHandler<GetWlpAgentRequest,​GetWlpAgentResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a WlpAgent resource for an on-premise resource identified by wlpAgentId.
        Specified by:
        getWlpAgent in interface CloudGuardAsync
        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

        public Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                                             AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns details for a work request (WorkRequest resource) identified by workRequestId.
        Specified by:
        getWorkRequest in interface CloudGuardAsync
        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.
      • listAdhocQueries

        public Future<ListAdhocQueriesResponse> listAdhocQueries​(ListAdhocQueriesRequest request,
                                                                 AsyncHandler<ListAdhocQueriesRequest,​ListAdhocQueriesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of all adhoc queries (AdhocQuery resources) for a compartment identified by compartmentId.

        List is returned in a AdhocQueryCollection resource with page of AdhocQuerySummary resources.

        The ListAdhocQueries operation returns only the adhoc queries in 'compartmentId' passed. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListAdhocQueries on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listAdhocQueries in interface CloudGuardAsync
        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.
      • listDataMaskRules

        public Future<ListDataMaskRulesResponse> listDataMaskRules​(ListDataMaskRulesRequest request,
                                                                   AsyncHandler<ListDataMaskRulesRequest,​ListDataMaskRulesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of all DataMaskRule resources in the specified compartmentId (OCID) and its subcompartments.
        Specified by:
        listDataMaskRules in interface CloudGuardAsync
        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.
      • listDataSourceEvents

        public Future<ListDataSourceEventsResponse> listDataSourceEvents​(ListDataSourceEventsRequest request,
                                                                         AsyncHandler<ListDataSourceEventsRequest,​ListDataSourceEventsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of data source events (DataSourceEventCollection resource) from the data source (DataSource resource) identified by dataSourceId.
        Specified by:
        listDataSourceEvents in interface CloudGuardAsync
        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.
      • listDataSources

        public Future<ListDataSourcesResponse> listDataSources​(ListDataSourcesRequest request,
                                                               AsyncHandler<ListDataSourcesRequest,​ListDataSourcesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of all data sources (DataSource resources) for a compartment identified by compartmentId.

        List is returned in a DataSourceCollection resource with page of DataSourceSummary resources.

        The ListAdhocQueries operation returns only the adhoc queries in 'compartmentId' passed. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListAdhocQueries on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listDataSources in interface CloudGuardAsync
        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.
      • listDetectorRecipes

        public Future<ListDetectorRecipesResponse> listDetectorRecipes​(ListDetectorRecipesRequest request,
                                                                       AsyncHandler<ListDetectorRecipesRequest,​ListDetectorRecipesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of all detector recipes (DetectorRecipe resources) in a compartment, identified by compartmentId.

        The ListDetectorRecipes operation returns only the detector recipes in `compartmentId` passed. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListDetectorRecipes on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listDetectorRecipes in interface CloudGuardAsync
        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.
      • listDetectorRules

        public Future<ListDetectorRulesResponse> listDetectorRules​(ListDetectorRulesRequest request,
                                                                   AsyncHandler<ListDetectorRulesRequest,​ListDetectorRulesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of detector rules for the DetectorRecipe resource identified by detectorId.
        Specified by:
        listDetectorRules in interface CloudGuardAsync
        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.
      • listDetectors

        public Future<ListDetectorsResponse> listDetectors​(ListDetectorsRequest request,
                                                           AsyncHandler<ListDetectorsRequest,​ListDetectorsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a detector catalog (DetectorCollection resource) with a list of DetectorSummary resources.
        Specified by:
        listDetectors in interface CloudGuardAsync
        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.
      • listManagedLists

        public Future<ListManagedListsResponse> listManagedLists​(ListManagedListsRequest request,
                                                                 AsyncHandler<ListManagedListsRequest,​ListManagedListsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of all ManagedList resources in a compartment, identified by compartmentId.

        The ListManagedLists operation returns only the managed lists in compartmentId passed. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return ManagedLists in only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListManagedLists on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listManagedLists in interface CloudGuardAsync
        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.
      • listPolicies

        public Future<ListPoliciesResponse> listPolicies​(ListPoliciesRequest request,
                                                         AsyncHandler<ListPoliciesRequest,​ListPoliciesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns the list of global policy statements (policy attributes) needed to fully enable Cloud Guard.
        Specified by:
        listPolicies in interface CloudGuardAsync
        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.
      • listProblems

        public Future<ListProblemsResponse> listProblems​(ListProblemsRequest request,
                                                         AsyncHandler<ListProblemsRequest,​ListProblemsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of all Problems identified by Cloud Guard which are currently in the database and meet the filtering criteria.

        The ListProblems operation returns only the problems in `compartmentId` passed. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListProblems on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listProblems in interface CloudGuardAsync
        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.
      • listRecommendations

        public Future<ListRecommendationsResponse> listRecommendations​(ListRecommendationsRequest request,
                                                                       AsyncHandler<ListRecommendationsRequest,​ListRecommendationsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of recommendations (RecommendationSummaryCollection resource with a page of RecommendationSummary resources) for a specified compartment OCID.
        Specified by:
        listRecommendations in interface CloudGuardAsync
        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.
      • listResourcePorts

        public Future<ListResourcePortsResponse> listResourcePorts​(ListResourcePortsRequest request,
                                                                   AsyncHandler<ListResourcePortsRequest,​ListResourcePortsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns the list of open ports associated with the resourceId where resource is an instance
        Specified by:
        listResourcePorts in interface CloudGuardAsync
        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.
      • listResourceProfiles

        public Future<ListResourceProfilesResponse> listResourceProfiles​(ListResourceProfilesRequest request,
                                                                         AsyncHandler<ListResourceProfilesRequest,​ListResourceProfilesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of all resource profile summaries (ResourceProfileCollection resource with a page of ResourceProfileSummary resources) for a compartment, identified by compartmentId and filtered as specified.

        The ListResourceProfiles operation returns only the resource profiles in `compartmentId` passed. The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListResourceProfiles on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listResourceProfiles in interface CloudGuardAsync
        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.
      • listResourceTypes

        public Future<ListResourceTypesResponse> listResourceTypes​(ListResourceTypesRequest request,
                                                                   AsyncHandler<ListResourceTypesRequest,​ListResourceTypesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a single ResourceTypeCollection resource, containing a list of resource types, identified by parameters specified.
        Specified by:
        listResourceTypes in interface CloudGuardAsync
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listResources

        public Future<ListResourcesResponse> listResources​(ListResourcesRequest request,
                                                           AsyncHandler<ListResourcesRequest,​ListResourcesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of all resources in a compartment

        The ListResources operation returns only the resources in `compartmentId` passed. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListResources on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listResources in interface CloudGuardAsync
        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.
      • listResponderRecipes

        public Future<ListResponderRecipesResponse> listResponderRecipes​(ListResponderRecipesRequest request,
                                                                         AsyncHandler<ListResponderRecipesRequest,​ListResponderRecipesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list (ResponderRecipeCollection resource, with a page of ResponderRecipeSummary resources) of all responder recipes (RespponderRecipe resources) in a compartment, identified by compartmentId.

        The ListResponderRecipe operation returns only the targets in compartmentId passed. The list does not include any subcompartments of the compartmentId passed.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListResponderRecipe on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listResponderRecipes in interface CloudGuardAsync
        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.
      • listResponderRules

        public Future<ListResponderRulesResponse> listResponderRules​(ListResponderRulesRequest request,
                                                                     AsyncHandler<ListResponderRulesRequest,​ListResponderRulesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of responder rules for the ResponderRecipe resource identified by responderId.

        The list is contained in a ResponderRuleCollection resource with a page of ResponderRuleSummary resources.

        Specified by:
        listResponderRules in interface CloudGuardAsync
        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.
      • listSecurityRecipes

        public Future<ListSecurityRecipesResponse> listSecurityRecipes​(ListSecurityRecipesRequest request,
                                                                       AsyncHandler<ListSecurityRecipesRequest,​ListSecurityRecipesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of security zone recipes (SecurityRecipeSummary resources) in a compartment, identified by compartmentId.
        Specified by:
        listSecurityRecipes in interface CloudGuardAsync
        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.
      • listSecurityZones

        public Future<ListSecurityZonesResponse> listSecurityZones​(ListSecurityZonesRequest request,
                                                                   AsyncHandler<ListSecurityZonesRequest,​ListSecurityZonesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of security zones (SecurityZone resources) in a compartment identified by compartmentId.

        List is contained in a page of SecurityZoneSummary resources.

        Specified by:
        listSecurityZones in interface CloudGuardAsync
        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.
      • listSightings

        public Future<ListSightingsResponse> listSightings​(ListSightingsRequest request,
                                                           AsyncHandler<ListSightingsRequest,​ListSightingsResponse> handler)
        Description copied from interface: CloudGuardAsync
        For the parameters passed, returns a list of sightings (SightingCollection resource) with a page of SightingSummary resources.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListSightings on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listSightings in interface CloudGuardAsync
        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.
      • listTactics

        public Future<ListTacticsResponse> listTactics​(ListTacticsRequest request,
                                                       AsyncHandler<ListTacticsRequest,​ListTacticsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of TacticSummary resources for a compartment, identified by compartmentId.
        Specified by:
        listTactics in interface CloudGuardAsync
        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.
      • listTargetDetectorRecipes

        public Future<ListTargetDetectorRecipesResponse> listTargetDetectorRecipes​(ListTargetDetectorRecipesRequest request,
                                                                                   AsyncHandler<ListTargetDetectorRecipesRequest,​ListTargetDetectorRecipesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of all target detector recipes (TargetDetectorRecipe resources) associated with a target (Target resource), identified by targetId.

        The list is contained in a TargetDetectorRecipeCollection resource with page of TargetDetectorRecipeSummary resources.

        Specified by:
        listTargetDetectorRecipes in interface CloudGuardAsync
        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.
      • listTargetResponderRecipes

        public Future<ListTargetResponderRecipesResponse> listTargetResponderRecipes​(ListTargetResponderRecipesRequest request,
                                                                                     AsyncHandler<ListTargetResponderRecipesRequest,​ListTargetResponderRecipesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of summary information for all responder recipes (TargetResponderRecipeCollection resource, with a page of TargetResponderRecipeSummary resources) attached to a target identified by targetId, located in a compartment identified by compartmentId.
        Specified by:
        listTargetResponderRecipes in interface CloudGuardAsync
        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.
      • listTargets

        public Future<ListTargetsResponse> listTargets​(ListTargetsRequest request,
                                                       AsyncHandler<ListTargetsRequest,​ListTargetsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of targets (TargetCollection resource with page of TargetSummary resources) for the target identified by compartmentId.

        By default, only the target associated with the compartment is returned. Setting compartmentIdInSubtree to true returns the entire hierarchy of targets in subcompartments.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform ListTargets on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all targets in compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        listTargets in interface CloudGuardAsync
        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.
      • listTechniques

        public Future<ListTechniquesResponse> listTechniques​(ListTechniquesRequest request,
                                                             AsyncHandler<ListTechniquesRequest,​ListTechniquesResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of techniques associated with detector rules.
        Specified by:
        listTechniques in interface CloudGuardAsync
        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.
      • listWlpAgents

        public Future<ListWlpAgentsResponse> listWlpAgents​(ListWlpAgentsRequest request,
                                                           AsyncHandler<ListWlpAgentsRequest,​ListWlpAgentsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of WLP agents in a compartment.
        Specified by:
        listWlpAgents in interface CloudGuardAsync
        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

        public Future<ListWorkRequestLogsResponse> listWorkRequestLogs​(ListWorkRequestLogsRequest request,
                                                                       AsyncHandler<ListWorkRequestLogsRequest,​ListWorkRequestLogsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a paginated list (WorkRequestLogEntryCollection resource) of log entries for a request, identified by workRequestId.
        Specified by:
        listWorkRequestLogs in interface CloudGuardAsync
        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

        public Future<ListWorkRequestsResponse> listWorkRequests​(ListWorkRequestsRequest request,
                                                                 AsyncHandler<ListWorkRequestsRequest,​ListWorkRequestsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a list of work requests (WorkRequestSummaryCollection resource), in a compartment identified by compartmentId.
        Specified by:
        listWorkRequests in interface CloudGuardAsync
        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.
      • removeCompartment

        public Future<RemoveCompartmentResponse> removeCompartment​(RemoveCompartmentRequest request,
                                                                   AsyncHandler<RemoveCompartmentRequest,​RemoveCompartmentResponse> handler)
        Description copied from interface: CloudGuardAsync
        Removes a compartment from a security zone (SecurityZone resource), identified by securityZoneId.

        Pass compartmentId of compartment to remove through a RemoveCompartmentDetails resource. When you remove a subcompartment from a security zone, it no longer enforces security zone policies on the resources in the subcompartment. You can’t remove the primary compartment that was used to create the security zone.

        Specified by:
        removeCompartment in interface CloudGuardAsync
        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.
      • requestRiskScores

        public Future<RequestRiskScoresResponse> requestRiskScores​(RequestRiskScoresRequest request,
                                                                   AsyncHandler<RequestRiskScoresRequest,​RequestRiskScoresResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a page of RiskScoreAggregation resources for a compartment, identified by compartmentId.
        Specified by:
        requestRiskScores in interface CloudGuardAsync
        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.
      • requestSecurityScores

        public Future<RequestSecurityScoresResponse> requestSecurityScores​(RequestSecurityScoresRequest request,
                                                                           AsyncHandler<RequestSecurityScoresRequest,​RequestSecurityScoresResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a page of SecurityScoreAggregation resources.

        These measure the number of resources examined across all regions and compare it with the number of problems detected.

        Specified by:
        requestSecurityScores in interface CloudGuardAsync
        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.
      • requestSummarizedActivityProblems

        public Future<RequestSummarizedActivityProblemsResponse> requestSummarizedActivityProblems​(RequestSummarizedActivityProblemsRequest request,
                                                                                                   AsyncHandler<RequestSummarizedActivityProblemsRequest,​RequestSummarizedActivityProblemsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns the summary of problems generated by OCI Activity Detector rules, identified by parameters specified.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform summarize API on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        The compartmentId to be passed with `accessLevel` and `compartmentIdInSubtree` params has to be the root compartment id (tenant-id) only.

        Specified by:
        requestSummarizedActivityProblems in interface CloudGuardAsync
        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.
      • requestSummarizedProblems

        public Future<RequestSummarizedProblemsResponse> requestSummarizedProblems​(RequestSummarizedProblemsRequest request,
                                                                                   AsyncHandler<RequestSummarizedProblemsRequest,​RequestSummarizedProblemsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns the number of problems matching the key-value pairs in dimensionMap.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform summarize API on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        requestSummarizedProblems in interface CloudGuardAsync
        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.
      • requestSummarizedResponderExecutions

        public Future<RequestSummarizedResponderExecutionsResponse> requestSummarizedResponderExecutions​(RequestSummarizedResponderExecutionsRequest request,
                                                                                                         AsyncHandler<RequestSummarizedResponderExecutionsRequest,​RequestSummarizedResponderExecutionsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns the number of responder executions, identified by parameters specified, in a page of ResponderExecutionAggregation resources.

        Setting accessLevel to ACCESSIBLE returns only those compartments for which the user has INSPECT permissions, directly or indirectly (permissions can be on a resource in a subcompartment). \u201cNot Authorized\u201d is returned if user doesn't have access to at least one of the child compartments. When accessLevel is set to RESTRICTED, permissions are checked and no partial results are displayed. This is valid only when compartmentIdInSubtree is set to true.

        Setting accessLevel to ACCESSIBLE returns only those compartments for which the user has INSPECT permissions, directly or indirectly (permissions can be on a resource in a subcompartment). \u201cNot Authorized\u201d is returned if user doesn't have access to at least one of the child compartments. When accessLevel is set to RESTRICTED, permissions are checked and no partial results are displayed. This is valid only when compartmentIdInSubtree is set to true.

        Specified by:
        requestSummarizedResponderExecutions in interface CloudGuardAsync
        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.
      • requestSummarizedTrendProblems

        public Future<RequestSummarizedTrendProblemsResponse> requestSummarizedTrendProblems​(RequestSummarizedTrendProblemsRequest request,
                                                                                             AsyncHandler<RequestSummarizedTrendProblemsRequest,​RequestSummarizedTrendProblemsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns a ProblemTrendAggregationCollection resource for a compartment, identified by compartmentId, for the specified time period.

        The ProblemTrendAggregationCollection resource contains a list of ProblemTrendAggregation resources.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform summarize API on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        requestSummarizedTrendProblems in interface CloudGuardAsync
        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.
      • requestSummarizedTrendResponderExecutions

        public Future<RequestSummarizedTrendResponderExecutionsResponse> requestSummarizedTrendResponderExecutions​(RequestSummarizedTrendResponderExecutionsRequest request,
                                                                                                                   AsyncHandler<RequestSummarizedTrendResponderExecutionsRequest,​RequestSummarizedTrendResponderExecutionsResponse> handler)
        Description copied from interface: CloudGuardAsync
        Returns the number of remediations performed by Responders, for a given time period.

        The parameter `accessLevel` specifies whether to return only those compartments for which the requestor has INSPECT permissions on at least one resource directly or indirectly (ACCESSIBLE) (the resource can be in a subcompartment) or to return Not Authorized if Principal doesn't have access to even one of the child compartments. This is valid only when `compartmentIdInSubtree` is set to `true`.

        The parameter `compartmentIdInSubtree` applies when you perform summarize API on the `compartmentId` passed and when it is set to true, the entire hierarchy of compartments can be returned. To get a full list of all compartments and subcompartments in the tenancy (root compartment), set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ACCESSIBLE.

        Specified by:
        requestSummarizedTrendResponderExecutions in interface CloudGuardAsync
        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.
      • triggerResponder

        public Future<TriggerResponderResponse> triggerResponder​(TriggerResponderRequest request,
                                                                 AsyncHandler<TriggerResponderRequest,​TriggerResponderResponse> handler)
        Description copied from interface: CloudGuardAsync
        Sends the problem identified by problemId to the responder engine, to be processed by rule that\u2019s identified by responderRuleId, in the TriggerResponderDetails resource that\u2019s passed.
        Specified by:
        triggerResponder in interface CloudGuardAsync
        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.
      • updateBulkProblemStatus

        public Future<UpdateBulkProblemStatusResponse> updateBulkProblemStatus​(UpdateBulkProblemStatusRequest request,
                                                                               AsyncHandler<UpdateBulkProblemStatusRequest,​UpdateBulkProblemStatusResponse> handler)
        Description copied from interface: CloudGuardAsync
        Changes the status for all problems listed in the problemIds array, passed through the UpdateBulkProblemStatusDetails resource, from the current status to the status set in UpdateBulkProblemStatusDetails.
        Specified by:
        updateBulkProblemStatus in interface CloudGuardAsync
        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.
      • updateConfiguration

        public Future<UpdateConfigurationResponse> updateConfiguration​(UpdateConfigurationRequest request,
                                                                       AsyncHandler<UpdateConfigurationRequest,​UpdateConfigurationResponse> handler)
        Description copied from interface: CloudGuardAsync
        Updates configuration details for a Cloud Guard tenancy, identified by root compartment OCID.

        The reporting region cannot be updated once created.

        Specified by:
        updateConfiguration in interface CloudGuardAsync
        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.
      • updateDataSource

        public Future<UpdateDataSourceResponse> updateDataSource​(UpdateDataSourceRequest request,
                                                                 AsyncHandler<UpdateDataSourceRequest,​UpdateDataSourceResponse> handler)
        Description copied from interface: CloudGuardAsync
        Updates a data source (DataSource resource) identified by dataSourceId, using values passed in an UpdateDataSourceDetails resource.
        Specified by:
        updateDataSource in interface CloudGuardAsync
        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.
      • updateProblemStatus

        public Future<UpdateProblemStatusResponse> updateProblemStatus​(UpdateProblemStatusRequest request,
                                                                       AsyncHandler<UpdateProblemStatusRequest,​UpdateProblemStatusResponse> handler)
        Description copied from interface: CloudGuardAsync
        Changes the current status of the problem, identified by problemId, to the status specified in the UpdateProblemStatusDetails resource that you pass.
        Specified by:
        updateProblemStatus in interface CloudGuardAsync
        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.
      • updateSecurityRecipe

        public Future<UpdateSecurityRecipeResponse> updateSecurityRecipe​(UpdateSecurityRecipeRequest request,
                                                                         AsyncHandler<UpdateSecurityRecipeRequest,​UpdateSecurityRecipeResponse> handler)
        Description copied from interface: CloudGuardAsync
        Updates a security zone recipe (SecurityRecipe resource), identified by securityRecipeId, using parameters passed in an UpdateSecurityRecipeDetails resource.
        Specified by:
        updateSecurityRecipe in interface CloudGuardAsync
        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.
      • updateSecurityZone

        public Future<UpdateSecurityZoneResponse> updateSecurityZone​(UpdateSecurityZoneRequest request,
                                                                     AsyncHandler<UpdateSecurityZoneRequest,​UpdateSecurityZoneResponse> handler)
        Description copied from interface: CloudGuardAsync
        Updates a security zone (SecurityZone resource) identified by securityZoneId.

        Pass parameters through an UpdateSecurityZoneDetails resource.

        Specified by:
        updateSecurityZone in interface CloudGuardAsync
        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.
      • updateTarget

        public Future<UpdateTargetResponse> updateTarget​(UpdateTargetRequest request,
                                                         AsyncHandler<UpdateTargetRequest,​UpdateTargetResponse> handler)
        Description copied from interface: CloudGuardAsync
        Updates a target (Target resource) identified by targetId, using parameters passed in an UpdateTargetDetails resource.
        Specified by:
        updateTarget in interface CloudGuardAsync
        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.
      • updateWlpAgent

        public Future<UpdateWlpAgentResponse> updateWlpAgent​(UpdateWlpAgentRequest request,
                                                             AsyncHandler<UpdateWlpAgentRequest,​UpdateWlpAgentResponse> handler)
        Description copied from interface: CloudGuardAsync
        Updates and renews the certificate for an on-premise WLP agent identified by wlpAgentId.
        Specified by:
        updateWlpAgent in interface CloudGuardAsync
        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.
      • useRealmSpecificEndpointTemplate

        public void useRealmSpecificEndpointTemplate​(boolean useOfRealmSpecificEndpointTemplateEnabled)
        This method should be used to enable or disable the use of realm-specific endpoint template.

        The default value is null. To enable the use of endpoint template defined for the realm in use, set the flag to true To disable the use of endpoint template defined for the realm in use, set the flag to false

        Parameters:
        useOfRealmSpecificEndpointTemplateEnabled - This flag can be set to true or false to enable or disable the use of realm-specific endpoint template respectively
      • populateServiceParametersInEndpoint

        public final void populateServiceParametersInEndpoint​(String endpoint,
                                                              Map<String,​Object> requiredParametersMap)
        Populate the parameters in the endpoint with its corresponding value and update the base endpoint.

        The value will be populated iff the parameter in endpoint is a required request path parameter or a required request query parameter. If not, the parameter in the endpoint will be ignored and left blank.

        Parameters:
        endpoint - The endpoint template in use
        requiredParametersMap - Map of parameter name as key and value set in request path or query parameter as value
      • updateBaseEndpoint

        public final void updateBaseEndpoint​(String endpoint)
        This method should be used for parameterized endpoint templates only.

        This does not include {region} and {secondLevelDomain} parameters.

        Parameters:
        endpoint - The updated endpoint to use
      • setEndpoint

        public final void setEndpoint​(String endpoint)
      • getEndpoint

        public final String getEndpoint()
      • refreshClient

        public final void refreshClient()
        Rebuild the backing HttpClient.

        This will call ClientConfigurators again, and can be used to e.g. refresh the SSL certificate.

      • getClientCommonLibraryVersion

        public String getClientCommonLibraryVersion()
      • getMinimumClientCommonLibraryVersionFromClient

        public Optional<String> getMinimumClientCommonLibraryVersionFromClient()