Package com.oracle.bmc.healthchecks

Interface HealthChecksAsync

    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

        void setEndpoint​(String endpoint)
        Sets the endpoint to call (ex, https://www.example.com).
        Parameters:
        endpoint - The endpoint of the serice.

      • getEndpoint

        String getEndpoint()
        Gets the set endpoint for REST call (ex, https://www.example.com)

      • setRegion

        void setRegion​(Region region)
        Sets the region to call (ex, Region.US_PHOENIX_1).

        Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.

        Parameters:
        region - The region of the service.

      • setRegion

        void setRegion​(String regionId)
        Sets the region to call (ex, ‘us-phoenix-1’).

        Note, this will first try to map the region ID to a known Region and call setRegion.

        If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.

        Parameters:
        regionId - The public region ID.

      • useRealmSpecificEndpointTemplate

        void useRealmSpecificEndpointTemplate​(boolean realmSpecificEndpointTemplateEnabled)
        Determines whether realm specific endpoint should be used or not.

        Set realmSpecificEndpointTemplateEnabled to “true” if the user wants to enable use of realm specific endpoint template, otherwise set it to “false”

        Parameters:
        realmSpecificEndpointTemplateEnabled - flag to enable the use of realm specific endpoint template

      • changeHttpMonitorCompartment

        Future<ChangeHttpMonitorCompartmentResponse> changeHttpMonitorCompartment​(ChangeHttpMonitorCompartmentRequest request,
                                                                          AsyncHandler<ChangeHttpMonitorCompartmentRequest,​ChangeHttpMonitorCompartmentResponse> handler)
        Moves a monitor into a different compartment.

        When provided, If-Match is checked against ETag values of the resource.

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

      • changePingMonitorCompartment

        Future<ChangePingMonitorCompartmentResponse> changePingMonitorCompartment​(ChangePingMonitorCompartmentRequest request,
                                                                          AsyncHandler<ChangePingMonitorCompartmentRequest,​ChangePingMonitorCompartmentResponse> handler)
        Moves a monitor into a different compartment.

        When provided, If-Match is checked against ETag values of the resource.

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

      • createHttpMonitor

        Future<CreateHttpMonitorResponse> createHttpMonitor​(CreateHttpMonitorRequest request,
                                                    AsyncHandler<CreateHttpMonitorRequest,​CreateHttpMonitorResponse> handler)
        Creates an HTTP monitor.

        Vantage points will be automatically selected if not specified, and probes will be initiated from each vantage point to each of the targets at the frequency specified by intervalInSeconds.

        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.

      • createOnDemandHttpProbe

        Future<CreateOnDemandHttpProbeResponse> createOnDemandHttpProbe​(CreateOnDemandHttpProbeRequest request,
                                                                AsyncHandler<CreateOnDemandHttpProbeRequest,​CreateOnDemandHttpProbeResponse> handler)
        Creates an on-demand HTTP probe.

        The location response header contains the URL for fetching the probe results.

        Note:* On-demand probe configurations are not saved.

        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.

      • createOnDemandPingProbe

        Future<CreateOnDemandPingProbeResponse> createOnDemandPingProbe​(CreateOnDemandPingProbeRequest request,
                                                                AsyncHandler<CreateOnDemandPingProbeRequest,​CreateOnDemandPingProbeResponse> handler)
        Creates an on-demand ping probe.

        The location response header contains the URL for fetching probe results.

        Note:* The on-demand probe configuration is not saved.

        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.

      • createPingMonitor

        Future<CreatePingMonitorResponse> createPingMonitor​(CreatePingMonitorRequest request,
                                                    AsyncHandler<CreatePingMonitorRequest,​CreatePingMonitorResponse> handler)
        Creates a ping monitor.

        Vantage points will be automatically selected if not specified, and probes will be initiated from each vantage point to each of the targets at the frequency specified by intervalInSeconds.

        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.

      • deleteHttpMonitor

        Future<DeleteHttpMonitorResponse> deleteHttpMonitor​(DeleteHttpMonitorRequest request,
                                                    AsyncHandler<DeleteHttpMonitorRequest,​DeleteHttpMonitorResponse> handler)
        Deletes the HTTP monitor and its configuration.

        All future probes of this monitor are stopped. Results associated with the monitor are not deleted.

        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.

      • deletePingMonitor

        Future<DeletePingMonitorResponse> deletePingMonitor​(DeletePingMonitorRequest request,
                                                    AsyncHandler<DeletePingMonitorRequest,​DeletePingMonitorResponse> handler)
        Deletes the ping monitor and its configuration.

        All future probes of this monitor are stopped. Results associated with the monitor are not deleted.

        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.

      • getHttpMonitor

        Future<GetHttpMonitorResponse> getHttpMonitor​(GetHttpMonitorRequest request,
                                              AsyncHandler<GetHttpMonitorRequest,​GetHttpMonitorResponse> handler)
        Gets the configuration for the specified monitor.
        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.

      • getPingMonitor

        Future<GetPingMonitorResponse> getPingMonitor​(GetPingMonitorRequest request,
                                              AsyncHandler<GetPingMonitorRequest,​GetPingMonitorResponse> handler)
        Gets the configuration for the specified ping monitor.
        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.

      • listHttpMonitors

        Future<ListHttpMonitorsResponse> listHttpMonitors​(ListHttpMonitorsRequest request,
                                                  AsyncHandler<ListHttpMonitorsRequest,​ListHttpMonitorsResponse> handler)
        Gets a list of HTTP monitors.
        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.

      • listHttpProbeResults

        Future<ListHttpProbeResultsResponse> listHttpProbeResults​(ListHttpProbeResultsRequest request,
                                                          AsyncHandler<ListHttpProbeResultsRequest,​ListHttpProbeResultsResponse> handler)
        Gets the HTTP probe results for the specified probe or monitor, where the probeConfigurationId is the OCID of either a monitor or an on-demand probe.
        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.

      • listPingMonitors

        Future<ListPingMonitorsResponse> listPingMonitors​(ListPingMonitorsRequest request,
                                                  AsyncHandler<ListPingMonitorsRequest,​ListPingMonitorsResponse> handler)
        Gets a list of configured ping monitors.

        Results are paginated based on `page` and `limit`. The `opc-next-page` header provides a URL for fetching the next page.

        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.

      • listPingProbeResults

        Future<ListPingProbeResultsResponse> listPingProbeResults​(ListPingProbeResultsRequest request,
                                                          AsyncHandler<ListPingProbeResultsRequest,​ListPingProbeResultsResponse> handler)
        Returns the results for the specified probe, where the probeConfigurationId is the OCID of either a monitor or an on-demand probe.

        Results are paginated based on `page` and `limit`. The `opc-next-page` header provides a URL for fetching the next page. Use `sortOrder` to set the order of the results. If `sortOrder` is unspecified, results are sorted in ascending order by `startTime`.

        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.

      • updateHttpMonitor

        Future<UpdateHttpMonitorResponse> updateHttpMonitor​(UpdateHttpMonitorRequest request,
                                                    AsyncHandler<UpdateHttpMonitorRequest,​UpdateHttpMonitorResponse> handler)
        Updates the configuration of the specified HTTP monitor.

        Only the fields specified in the request body will be updated; all other configuration properties will remain unchanged.

        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.

      • updatePingMonitor

        Future<UpdatePingMonitorResponse> updatePingMonitor​(UpdatePingMonitorRequest request,
                                                    AsyncHandler<UpdatePingMonitorRequest,​UpdatePingMonitorResponse> handler)
        Updates the configuration of the specified ping monitor.

        Only the fields specified in the request body will be updated; all other configuration properties will remain unchanged.

        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.