Package com.oracle.bmc.core

Interface ComputeManagementAsync

    • 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

      • attachLoadBalancer

        Future<AttachLoadBalancerResponse> attachLoadBalancer​(AttachLoadBalancerRequest request,
                                                      AsyncHandler<AttachLoadBalancerRequest,​AttachLoadBalancerResponse> handler)
        Attach a load balancer to the instance pool.
        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.

      • changeInstanceConfigurationCompartment

        Future<ChangeInstanceConfigurationCompartmentResponse> changeInstanceConfigurationCompartment​(ChangeInstanceConfigurationCompartmentRequest request,
                                                                                              AsyncHandler<ChangeInstanceConfigurationCompartmentRequest,​ChangeInstanceConfigurationCompartmentResponse> handler)
        Moves an instance configuration into a different compartment within the same tenancy.

        For information about moving resources between compartments, see Moving Resources to a Different Compartment.

        When you move an instance configuration to a different compartment, associated resources such as instance pools are not moved.

        *Important:** Most of the properties for an existing instance configuration, including the compartment, cannot be modified after you create the instance configuration. Although you can move an instance configuration to a different compartment, you will not be able to use the instance configuration to manage instance pools in the new compartment. If you want to update an instance configuration to point to a different compartment, you should instead create a new instance configuration in the target compartment using [CreateInstanceConfiguration](https://docs.oracle.com/iaas/api/#/en/iaas/20160918/InstanceConfiguration/CreateInstanceConfiguration).

        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.

      • changeInstancePoolCompartment

        Future<ChangeInstancePoolCompartmentResponse> changeInstancePoolCompartment​(ChangeInstancePoolCompartmentRequest request,
                                                                            AsyncHandler<ChangeInstancePoolCompartmentRequest,​ChangeInstancePoolCompartmentResponse> handler)
        Moves an instance pool into a different compartment within the same tenancy.

        For information about moving resources between compartments, see Moving Resources to a Different Compartment.

        When you move an instance pool to a different compartment, associated resources such as the instances in the pool, boot volumes, VNICs, and autoscaling configurations are not moved.

        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.

      • createClusterNetwork

        Future<CreateClusterNetworkResponse> createClusterNetwork​(CreateClusterNetworkRequest request,
                                                          AsyncHandler<CreateClusterNetworkRequest,​CreateClusterNetworkResponse> handler)
        Creates a cluster network with instance pools.

        A cluster network is a group of high performance computing (HPC), GPU, or optimized bare metal instances that are connected with an ultra low-latency remote direct memory access (RDMA) network. Cluster networks with instance pools use instance pools to manage groups of identical instances.

        Use cluster networks with instance pools when you want predictable capacity for a specific number of identical instances that are managed as a group.

        If you want to manage instances in the RDMA network independently of each other or use different types of instances in the network group, create a compute cluster by using the createComputeCluster operation.

        To determine whether capacity is available for a specific shape before you create a cluster network, use the createComputeCapacityReport operation.

        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.

      • createInstanceConfiguration

        Future<CreateInstanceConfigurationResponse> createInstanceConfiguration​(CreateInstanceConfigurationRequest request,
                                                                        AsyncHandler<CreateInstanceConfigurationRequest,​CreateInstanceConfigurationResponse> handler)
        Creates an instance configuration.

        An instance configuration is a template that defines the settings to use when creating Compute instances.

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

      • createInstancePool

        Future<CreateInstancePoolResponse> createInstancePool​(CreateInstancePoolRequest request,
                                                      AsyncHandler<CreateInstancePoolRequest,​CreateInstancePoolResponse> handler)
        Creates an instance pool.

        To determine whether capacity is available for a specific shape before you create an instance pool, use the createComputeCapacityReport operation.

        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.

      • detachLoadBalancer

        Future<DetachLoadBalancerResponse> detachLoadBalancer​(DetachLoadBalancerRequest request,
                                                      AsyncHandler<DetachLoadBalancerRequest,​DetachLoadBalancerResponse> handler)
        Detach a load balancer from the instance pool.
        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.

      • getInstancePool

        Future<GetInstancePoolResponse> getInstancePool​(GetInstancePoolRequest request,
                                                AsyncHandler<GetInstancePoolRequest,​GetInstancePoolResponse> handler)
        Gets the specified instance pool
        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.

      • getInstancePoolInstance

        Future<GetInstancePoolInstanceResponse> getInstancePoolInstance​(GetInstancePoolInstanceRequest request,
                                                                AsyncHandler<GetInstancePoolInstanceRequest,​GetInstancePoolInstanceResponse> handler)
        Gets information about an instance that belongs to an instance pool.
        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.

      • launchInstanceConfiguration

        Future<LaunchInstanceConfigurationResponse> launchInstanceConfiguration​(LaunchInstanceConfigurationRequest request,
                                                                        AsyncHandler<LaunchInstanceConfigurationRequest,​LaunchInstanceConfigurationResponse> handler)
        Creates an instance from an instance configuration.

        If the instance configuration does not include all of the parameters that are required to create an instance, such as the availability domain and subnet ID, you must provide these parameters when you create an instance from the instance configuration. For more information, see the InstanceConfiguration resource.

        To determine whether capacity is available for a specific shape before you create an instance, use the createComputeCapacityReport operation.

        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.

      • listInstancePools

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

      • resetInstancePool

        Future<ResetInstancePoolResponse> resetInstancePool​(ResetInstancePoolRequest request,
                                                    AsyncHandler<ResetInstancePoolRequest,​ResetInstancePoolResponse> handler)
        Performs the reset (immediate power off and power on) action on the specified instance pool, which performs the action on all the instances in the pool.
        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.

      • softresetInstancePool

        Future<SoftresetInstancePoolResponse> softresetInstancePool​(SoftresetInstancePoolRequest request,
                                                            AsyncHandler<SoftresetInstancePoolRequest,​SoftresetInstancePoolResponse> handler)
        Performs the softreset (ACPI shutdown and power on) action on the specified instance pool, which performs the action on all the instances in the pool.

        Softreset gracefully reboots the instances by sending a shutdown command to the operating systems. After waiting 15 minutes for the OS to shut down, the instances are powered off and then powered back on.

        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.

      • softstopInstancePool

        Future<SoftstopInstancePoolResponse> softstopInstancePool​(SoftstopInstancePoolRequest request,
                                                          AsyncHandler<SoftstopInstancePoolRequest,​SoftstopInstancePoolResponse> handler)
        Performs the softstop (ACPI shutdown and power on) action on the specified instance pool, which performs the action on all the instances in the pool.

        Softstop gracefully reboots the instances by sending a shutdown command to the operating systems. After waiting 15 minutes for the OS to shutdown, the instances are powered off and then powered back on.

        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.

      • startInstancePool

        Future<StartInstancePoolResponse> startInstancePool​(StartInstancePoolRequest request,
                                                    AsyncHandler<StartInstancePoolRequest,​StartInstancePoolResponse> handler)
        Performs the start (power on) action on the specified instance pool, which performs the action on all the instances in the pool.
        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.

      • stopInstancePool

        Future<StopInstancePoolResponse> stopInstancePool​(StopInstancePoolRequest request,
                                                  AsyncHandler<StopInstancePoolRequest,​StopInstancePoolResponse> handler)
        Performs the stop (immediate power off) action on the specified instance pool, which performs the action on all the instances in the pool.
        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.

      • terminateInstancePool

        Future<TerminateInstancePoolResponse> terminateInstancePool​(TerminateInstancePoolRequest request,
                                                            AsyncHandler<TerminateInstancePoolRequest,​TerminateInstancePoolResponse> handler)
        Terminate the specified instance pool.

        *Warning:** When you delete an instance pool, the resources that were created by the pool are permanently deleted, including associated instances, attached boot volumes, and block volumes.

        If an autoscaling configuration applies to the instance pool, the autoscaling configuration will be deleted asynchronously after the pool is deleted. You can also manually delete the autoscaling configuration using the `DeleteAutoScalingConfiguration` operation in the Autoscaling API.

        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.

      • updateInstancePool

        Future<UpdateInstancePoolResponse> updateInstancePool​(UpdateInstancePoolRequest request,
                                                      AsyncHandler<UpdateInstancePoolRequest,​UpdateInstancePoolResponse> handler)
        Update the specified instance pool.

        The OCID of the instance pool remains the same.

        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.