Class: OCI::LoadBalancer::LoadBalancerClient

Inherits:

Object

Object
OCI::LoadBalancer::LoadBalancerClient

show all

Defined in:: lib/oci/load_balancer/load_balancer_client.rb

Overview

API for the Load Balancing service. Use this API to manage load balancers, backend sets, and related items. For more information, see [Overview of Load Balancing](/iaas/Content/Balance/Concepts/balanceoverview.htm).

Instance Attribute Summary collapse

#api_client ⇒ OCI::ApiClient readonly

Client used to make HTTP requests.
#endpoint ⇒ String readonly

Fully qualified endpoint URL.
#region ⇒ String

The region, which will usually correspond to a value in Regions::REGION_ENUM.
#retry_config ⇒ OCI::Retry::RetryConfig readonly

The default retry configuration to apply to all operations in this service client.

Instance Method Summary collapse

#change_load_balancer_compartment(load_balancer_id, change_load_balancer_compartment_details, opts = {}) ⇒ Response

Moves a load balancer into a different compartment within the same tenancy.
#create_backend(create_backend_details, load_balancer_id, backend_set_name, opts = {}) ⇒ Response

Adds a backend server to a backend set.
#create_backend_set(create_backend_set_details, load_balancer_id, opts = {}) ⇒ Response

Adds a backend set to a load balancer.
#create_certificate(create_certificate_details, load_balancer_id, opts = {}) ⇒ Response

Creates an asynchronous request to add an SSL certificate bundle.
#create_hostname(create_hostname_details, load_balancer_id, opts = {}) ⇒ Response

Adds a hostname resource to the specified load balancer.
#create_listener(create_listener_details, load_balancer_id, opts = {}) ⇒ Response

Adds a listener to a load balancer.
#create_load_balancer(create_load_balancer_details, opts = {}) ⇒ Response

Creates a new load balancer in the specified compartment.
#create_path_route_set(create_path_route_set_details, load_balancer_id, opts = {}) ⇒ Response

Adds a path route set to a load balancer.
#create_routing_policy(create_routing_policy_details, load_balancer_id, opts = {}) ⇒ Response

Adds a routing policy to a load balancer.
#create_rule_set(load_balancer_id, create_rule_set_details, opts = {}) ⇒ Response

Creates a new rule set associated with the specified load balancer.
#create_ssl_cipher_suite(create_ssl_cipher_suite_details, load_balancer_id, opts = {}) ⇒ Response

Creates a custom SSL cipher suite.
#delete_backend(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ Response

Removes a backend server from a given load balancer and backend set.
#delete_backend_set(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

Deletes the specified backend set.
#delete_certificate(load_balancer_id, certificate_name, opts = {}) ⇒ Response

Deletes an SSL certificate bundle from a load balancer.
#delete_hostname(load_balancer_id, name, opts = {}) ⇒ Response

Deletes a hostname resource from the specified load balancer.
#delete_listener(load_balancer_id, listener_name, opts = {}) ⇒ Response

Deletes a listener from a load balancer.
#delete_load_balancer(load_balancer_id, opts = {}) ⇒ Response

Stops a load balancer and removes it from service.
#delete_path_route_set(load_balancer_id, path_route_set_name, opts = {}) ⇒ Response

Deletes a path route set from the specified load balancer.
#delete_routing_policy(load_balancer_id, routing_policy_name, opts = {}) ⇒ Response

Deletes a routing policy from the specified load balancer.
#delete_rule_set(load_balancer_id, rule_set_name, opts = {}) ⇒ Response

Deletes a rule set from the specified load balancer.
#delete_ssl_cipher_suite(load_balancer_id, name, opts = {}) ⇒ Response

Deletes an SSL cipher suite from a load balancer.
#get_backend(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ Response

Gets the specified backend server’s configuration information.
#get_backend_health(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ Response

Gets the current health status of the specified backend server.
#get_backend_set(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

Gets the specified backend set’s configuration information.
#get_backend_set_health(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

Gets the health status for the specified backend set.
#get_health_checker(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

Gets the health check policy information for a given load balancer and backend set.
#get_hostname(load_balancer_id, name, opts = {}) ⇒ Response

Gets the specified hostname resource’s configuration information.
#get_load_balancer(load_balancer_id, opts = {}) ⇒ Response

Gets the specified load balancer’s configuration information.
#get_load_balancer_health(load_balancer_id, opts = {}) ⇒ Response

Gets the health status for the specified load balancer.
#get_path_route_set(load_balancer_id, path_route_set_name, opts = {}) ⇒ Response

Gets the specified path route set’s configuration information.
#get_routing_policy(load_balancer_id, routing_policy_name, opts = {}) ⇒ Response

Gets the specified routing policy.
#get_rule_set(load_balancer_id, rule_set_name, opts = {}) ⇒ Response

Gets the specified set of rules.
#get_ssl_cipher_suite(load_balancer_id, name, opts = {}) ⇒ Response

Gets the specified SSL cipher suite’s configuration information.
#get_work_request(work_request_id, opts = {}) ⇒ Response

Gets the details of a work request.
#initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil) ⇒ LoadBalancerClient constructor

Creates a new LoadBalancerClient.
#list_backend_sets(load_balancer_id, opts = {}) ⇒ Response

Lists all backend sets associated with a given load balancer.
#list_backends(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

Lists the backend servers for a given load balancer and backend set.
#list_certificates(load_balancer_id, opts = {}) ⇒ Response

Lists all SSL certificates bundles associated with a given load balancer.
#list_hostnames(load_balancer_id, opts = {}) ⇒ Response

Lists all hostname resources associated with the specified load balancer.
#list_listener_rules(load_balancer_id, listener_name, opts = {}) ⇒ Response

Lists all of the rules from all of the rule sets associated with the specified listener.
#list_load_balancer_healths(compartment_id, opts = {}) ⇒ Response

Lists the summary health statuses for all load balancers in the specified compartment.
#list_load_balancers(compartment_id, opts = {}) ⇒ Response

Lists all load balancers in the specified compartment.
#list_path_route_sets(load_balancer_id, opts = {}) ⇒ Response

Lists all path route sets associated with the specified load balancer.
#list_policies(compartment_id, opts = {}) ⇒ Response

Lists the available load balancer policies.
#list_protocols(compartment_id, opts = {}) ⇒ Response

Lists all supported traffic protocols.
#list_routing_policies(load_balancer_id, opts = {}) ⇒ Response

Lists all routing policies associated with the specified load balancer.
#list_rule_sets(load_balancer_id, opts = {}) ⇒ Response

Lists all rule sets associated with the specified load balancer.
#list_shapes(compartment_id, opts = {}) ⇒ Response

Lists the valid load balancer shapes.
#list_ssl_cipher_suites(load_balancer_id, opts = {}) ⇒ Response

Lists all SSL cipher suites associated with the specified load balancer.
#list_work_requests(load_balancer_id, opts = {}) ⇒ Response

Lists the work requests for a given load balancer.
#logger ⇒ Logger

The logger for this client.
#update_backend(update_backend_details, load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ Response

Updates the configuration of a backend server within the specified backend set.
#update_backend_set(update_backend_set_details, load_balancer_id, backend_set_name, opts = {}) ⇒ Response

Updates a backend set.
#update_health_checker(health_checker, load_balancer_id, backend_set_name, opts = {}) ⇒ Response

Updates the health check policy for a given load balancer and backend set.
#update_hostname(update_hostname_details, load_balancer_id, name, opts = {}) ⇒ Response

Overwrites an existing hostname resource on the specified load balancer.
#update_listener(update_listener_details, load_balancer_id, listener_name, opts = {}) ⇒ Response

Updates a listener for a given load balancer.
#update_load_balancer(update_load_balancer_details, load_balancer_id, opts = {}) ⇒ Response

Updates a load balancer’s configuration.
#update_load_balancer_shape(load_balancer_id, update_load_balancer_shape_details, opts = {}) ⇒ Response

Update the shape of a load balancer.
#update_network_security_groups(update_network_security_groups_details, load_balancer_id, opts = {}) ⇒ Response

Updates the network security groups associated with the specified load balancer.
#update_path_route_set(update_path_route_set_details, load_balancer_id, path_route_set_name, opts = {}) ⇒ Response

Overwrites an existing path route set on the specified load balancer.
#update_routing_policy(update_routing_policy_details, load_balancer_id, routing_policy_name, opts = {}) ⇒ Response

Overwrites an existing routing policy on the specified load balancer.
#update_rule_set(load_balancer_id, rule_set_name, update_rule_set_details, opts = {}) ⇒ Response

Overwrites an existing set of rules on the specified load balancer.
#update_ssl_cipher_suite(update_ssl_cipher_suite_details, load_balancer_id, name, opts = {}) ⇒ Response

Updates an existing SSL cipher suite for the specified load balancer.

Constructor Details

#initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil) ⇒ `LoadBalancerClient`

Creates a new LoadBalancerClient. Notes:

If a config is not specified, then the global OCI.config will be used.

This client is not thread-safe

Either a region or an endpoint must be specified.  If an endpoint is specified, it will be used instead of the
  region. A region may be specified in the config or via or the region parameter. If specified in both, then the
  region parameter will be used.

Parameters:

config (Config) (defaults to: nil) —

A Config object.
region (String) (defaults to: nil) —

A region used to determine the service endpoint. This will usually correspond to a value in Regions::REGION_ENUM, but may be an arbitrary string.
endpoint (String) (defaults to: nil) —

The fully qualified endpoint URL
signer (OCI::BaseSigner) (defaults to: nil) —

A signer implementation which can be used by this client. If this is not provided then a signer will be constructed via the provided config. One use case of this parameter is instance principals authentication, so that the instance principals signer can be provided to the client
proxy_settings (OCI::ApiClientProxySettings) (defaults to: nil) —

If your environment requires you to use a proxy server for outgoing HTTP requests the details for the proxy can be provided in this parameter
retry_config (OCI::Retry::RetryConfig) (defaults to: nil) —

The retry configuration for this service client. This represents the default retry configuration to apply across all operations. This can be overridden on a per-operation basis. The default retry configuration value is nil, which means that an operation will not perform any retries

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 54

def initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil)
  # If the signer is an InstancePrincipalsSecurityTokenSigner or SecurityTokenSigner and no config was supplied (they are self-sufficient signers)
  # then create a dummy config to pass to the ApiClient constructor. If customers wish to create a client which uses instance principals
  # and has config (either populated programmatically or loaded from a file), they must construct that config themselves and then
  # pass it to this constructor.
  #
  # If there is no signer (or the signer is not an instance principals signer) and no config was supplied, this is not valid
  # so try and load the config from the default file.
  config = OCI::Config.validate_and_build_config_with_signer(config, signer)

  signer = OCI::Signer.config_file_auth_builder(config) if signer.nil?

  @api_client = OCI::ApiClient.new(config, signer, proxy_settings: proxy_settings)
  @retry_config = retry_config

  if endpoint
    @endpoint = endpoint + '/20170115'
  else
    region ||= config.region
    region ||= signer.region if signer.respond_to?(:region)
    self.region = region
  end
  logger.info "LoadBalancerClient endpoint set to '#{@endpoint}'." if logger
end

Instance Attribute Details

#api_client ⇒ `OCI::ApiClient` (readonly)

Client used to make HTTP requests.

Returns:

(OCI::ApiClient)



14
15
16

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 14

def api_client
  @api_client
end

#endpoint ⇒ `String` (readonly)

Fully qualified endpoint URL

Returns:

(String)



18
19
20

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 18

def endpoint
  @endpoint
end

#region ⇒ `String`

The region, which will usually correspond to a value in Regions::REGION_ENUM.

Returns:

(String)



28
29
30

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 28

def region
  @region
end

#retry_config ⇒ `OCI::Retry::RetryConfig` (readonly)

The default retry configuration to apply to all operations in this service client. This can be overridden on a per-operation basis. The default retry configuration value is nil, which means that an operation will not perform any retries

Returns:

(OCI::Retry::RetryConfig)



24
25
26

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 24

def retry_config
  @retry_config
end

Instance Method Details

#change_load_balancer_compartment(load_balancer_id, change_load_balancer_compartment_details, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/change_load_balancer_compartment.rb.html) to see an example of how to use change_load_balancer_compartment API.

Moves a load balancer into a different compartment within the same tenancy. For information about moving resources between compartments, see [Moving Resources to a Different Compartment](docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes).

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer to move.
change_load_balancer_compartment_details (OCI::LoadBalancer::Models::ChangeLoadBalancerCompartmentDetails) —

The configuration details for moving a load balancer to a different compartment.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).
:if_match (String) —
For optimistic concurrency control. Set the if-match parameter to the value of the ETag from a previous GET or POST response for that resource. The resource is moved only if the ETag you provide matches the resource’s current ETag value.

Example: example-etag
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 127

def change_load_balancer_compartment(load_balancer_id, change_load_balancer_compartment_details, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#change_load_balancer_compartment.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling change_load_balancer_compartment." if load_balancer_id.nil?
  raise "Missing the required parameter 'change_load_balancer_compartment_details' when calling change_load_balancer_compartment." if change_load_balancer_compartment_details.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/changeCompartment'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  header_params[:'if-match'] = opts[:if_match] if opts[:if_match]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(change_load_balancer_compartment_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#change_load_balancer_compartment') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_backend(create_backend_details, load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_backend.rb.html) to see an example of how to use create_backend API.

Adds a backend server to a backend set.

Parameters:

create_backend_details (OCI::LoadBalancer::Models::CreateBackendDetails) —

The details to add a backend server to a backend set.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set and servers.
backend_set_name (String) —

The name of the backend set to add the backend server to.

Example: example_backend_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 197

def create_backend(create_backend_details, load_balancer_id, backend_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_backend.' if logger

  raise "Missing the required parameter 'create_backend_details' when calling create_backend." if create_backend_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling create_backend." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling create_backend." if backend_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_backend_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_backend') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_backend_set(create_backend_set_details, load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_backend_set.rb.html) to see an example of how to use create_backend_set API.

Adds a backend set to a load balancer.

Parameters:

create_backend_set_details (OCI::LoadBalancer::Models::CreateBackendSetDetails) —

The details for adding a backend set.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer on which to add a backend set.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 264

def create_backend_set(create_backend_set_details, load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_backend_set.' if logger

  raise "Missing the required parameter 'create_backend_set_details' when calling create_backend_set." if create_backend_set_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling create_backend_set." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/backendSets'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_backend_set_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_backend_set') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_certificate(create_certificate_details, load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_certificate.rb.html) to see an example of how to use create_certificate API.

Creates an asynchronous request to add an SSL certificate bundle.

Parameters:

create_certificate_details (OCI::LoadBalancer::Models::CreateCertificateDetails) —

The details of the certificate bundle to add.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer on which to add the certificate bundle.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 329

def create_certificate(create_certificate_details, load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_certificate.' if logger

  raise "Missing the required parameter 'create_certificate_details' when calling create_certificate." if create_certificate_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling create_certificate." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/certificates'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_certificate_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_certificate') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_hostname(create_hostname_details, load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_hostname.rb.html) to see an example of how to use create_hostname API.

Adds a hostname resource to the specified load balancer. For more information, see [Managing Request Routing](docs.cloud.oracle.com/Content/Balance/Tasks/managingrequest.htm).

Parameters:

create_hostname_details (OCI::LoadBalancer::Models::CreateHostnameDetails) —

The details of the hostname resource to add to the specified load balancer.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer to add the hostname to.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 396

def create_hostname(create_hostname_details, load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_hostname.' if logger

  raise "Missing the required parameter 'create_hostname_details' when calling create_hostname." if create_hostname_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling create_hostname." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/hostnames'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_hostname_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_hostname') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_listener(create_listener_details, load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_listener.rb.html) to see an example of how to use create_listener API.

Adds a listener to a load balancer.

Parameters:

create_listener_details (OCI::LoadBalancer::Models::CreateListenerDetails) —

Details to add a listener.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer on which to add a listener.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 461

def create_listener(create_listener_details, load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_listener.' if logger

  raise "Missing the required parameter 'create_listener_details' when calling create_listener." if create_listener_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling create_listener." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/listeners'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_listener_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_listener') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_load_balancer(create_load_balancer_details, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_load_balancer.rb.html) to see an example of how to use create_load_balancer API.

Creates a new load balancer in the specified compartment. For general information about load balancers, see [Overview of the Load Balancing Service](docs.cloud.oracle.com/Content/Balance/Concepts/balanceoverview.htm).

For the purposes of access control, you must provide the OCID of the compartment where you want the load balancer to reside. Notice that the load balancer doesn’t have to be in the same compartment as the VCN or backend set. If you’re not sure which compartment to use, put the load balancer in the same compartment as the VCN. For information about access control and compartments, see [Overview of the IAM Service](docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm).

You must specify a display name for the load balancer. It does not have to be unique, and you can change it.

For information about Availability Domains, see [Regions and Availability Domains](docs.cloud.oracle.com/Content/General/Concepts/regions.htm). To get a list of Availability Domains, use the ListAvailabilityDomains operation in the Identity and Access Management Service API.

All Oracle Cloud Infrastructure resources, including load balancers, get an Oracle-assigned, unique ID called an Oracle Cloud Identifier (OCID). When you create a resource, you can find its OCID in the response. You can also retrieve a resource’s OCID by using a List API operation on that resource type, or by viewing the resource in the Console. Fore more information, see [Resource Identifiers](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm).

After you send your request, the new object’s state will temporarily be PROVISIONING. Before using the object, first make sure its state has changed to RUNNING.

When you create a load balancer, the system assigns an IP address. To get the IP address, use the get_load_balancer operation.

Parameters:

create_load_balancer_details (OCI::LoadBalancer::Models::CreateLoadBalancerDetails) —

The configuration details for creating a load balancer.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 552

def create_load_balancer(create_load_balancer_details, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_load_balancer.' if logger

  raise "Missing the required parameter 'create_load_balancer_details' when calling create_load_balancer." if create_load_balancer_details.nil?

  path = '/loadBalancers'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_load_balancer_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_load_balancer') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_path_route_set(create_path_route_set_details, load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_path_route_set.rb.html) to see an example of how to use create_path_route_set API.

Adds a path route set to a load balancer. For more information, see [Managing Request Routing](docs.cloud.oracle.com/Content/Balance/Tasks/managingrequest.htm).

Parameters:

create_path_route_set_details (OCI::LoadBalancer::Models::CreatePathRouteSetDetails) —

The details of the path route set to add.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer to add the path route set to.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 617

def create_path_route_set(create_path_route_set_details, load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_path_route_set.' if logger

  raise "Missing the required parameter 'create_path_route_set_details' when calling create_path_route_set." if create_path_route_set_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling create_path_route_set." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/pathRouteSets'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_path_route_set_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_path_route_set') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_routing_policy(create_routing_policy_details, load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_routing_policy.rb.html) to see an example of how to use create_routing_policy API.

Adds a routing policy to a load balancer. For more information, see [Managing Request Routing](docs.cloud.oracle.com/Content/Balance/Tasks/managingrequest.htm).

Parameters:

create_routing_policy_details (OCI::LoadBalancer::Models::CreateRoutingPolicyDetails) —

The details of the routing policy rules to add.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer to add the routing policy rule list to.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 684

def create_routing_policy(create_routing_policy_details, load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_routing_policy.' if logger

  raise "Missing the required parameter 'create_routing_policy_details' when calling create_routing_policy." if create_routing_policy_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling create_routing_policy." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/routingPolicies'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_routing_policy_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_routing_policy') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_rule_set(load_balancer_id, create_rule_set_details, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_rule_set.rb.html) to see an example of how to use create_rule_set API.

Creates a new rule set associated with the specified load balancer. For more information, see [Managing Rule Sets](docs.cloud.oracle.com/Content/Balance/Tasks/managingrulesets.htm).

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the specified load balancer.
create_rule_set_details (OCI::LoadBalancer::Models::CreateRuleSetDetails) —

The configuration details for the rule set to create.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 745

def create_rule_set(load_balancer_id, create_rule_set_details, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_rule_set.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling create_rule_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'create_rule_set_details' when calling create_rule_set." if create_rule_set_details.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/ruleSets'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(create_rule_set_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_rule_set') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#create_ssl_cipher_suite(create_ssl_cipher_suite_details, load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/create_ssl_cipher_suite.rb.html) to see an example of how to use create_ssl_cipher_suite API.

Creates a custom SSL cipher suite.

Parameters:

create_ssl_cipher_suite_details (OCI::LoadBalancer::Models::CreateSSLCipherSuiteDetails) —

The details of the SSL cipher suite to add.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the associated load balancer.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 809

def create_ssl_cipher_suite(create_ssl_cipher_suite_details, load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#create_ssl_cipher_suite.' if logger

  raise "Missing the required parameter 'create_ssl_cipher_suite_details' when calling create_ssl_cipher_suite." if create_ssl_cipher_suite_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling create_ssl_cipher_suite." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/sslCipherSuites'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(create_ssl_cipher_suite_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#create_ssl_cipher_suite') do
    @api_client.call_api(
      :POST,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_backend(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_backend.rb.html) to see an example of how to use delete_backend API.

Removes a backend server from a given load balancer and backend set.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set and server.
backend_set_name (String) —

The name of the backend set associated with the backend server.

Example: example_backend_set
backend_name (String) —

The IP address and port of the backend server to remove.

Example: 10.0.0.3:8080
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 875

def delete_backend(load_balancer_id, backend_set_name, backend_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_backend.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_backend." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling delete_backend." if backend_set_name.nil?
  raise "Missing the required parameter 'backend_name' when calling delete_backend." if backend_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)
  raise "Parameter value for 'backend_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends/{backendName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s).sub('{backendName}', backend_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_backend') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_backend_set(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_backend_set.rb.html) to see an example of how to use delete_backend_set API.

Deletes the specified backend set. Note that deleting a backend set removes its backend servers from the load balancer.

Before you can delete a backend set, you must remove it from any active listeners.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set.
backend_set_name (String) —

The name of the backend set to delete.

Example: example_backend_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 941

def delete_backend_set(load_balancer_id, backend_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_backend_set.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_backend_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling delete_backend_set." if backend_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_backend_set') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_certificate(load_balancer_id, certificate_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_certificate.rb.html) to see an example of how to use delete_certificate API.

Deletes an SSL certificate bundle from a load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the certificate bundle to be deleted.
certificate_name (String) —

The name of the certificate bundle to delete.

Example: example_certificate_bundle
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1004

def delete_certificate(load_balancer_id, certificate_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_certificate.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_certificate." if load_balancer_id.nil?
  raise "Missing the required parameter 'certificate_name' when calling delete_certificate." if certificate_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'certificate_name' must not be blank" if OCI::Internal::Util.blank_string?(certificate_name)

  path = '/loadBalancers/{loadBalancerId}/certificates/{certificateName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{certificateName}', certificate_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_certificate') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_hostname(load_balancer_id, name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_hostname.rb.html) to see an example of how to use delete_hostname API.

Deletes a hostname resource from the specified load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the hostname to delete.
name (String) —

The name of the hostname resource to delete.

Example: example_hostname_001
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1066

def delete_hostname(load_balancer_id, name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_hostname.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_hostname." if load_balancer_id.nil?
  raise "Missing the required parameter 'name' when calling delete_hostname." if name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'name' must not be blank" if OCI::Internal::Util.blank_string?(name)

  path = '/loadBalancers/{loadBalancerId}/hostnames/{name}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{name}', name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_hostname') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_listener(load_balancer_id, listener_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_listener.rb.html) to see an example of how to use delete_listener API.

Deletes a listener from a load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the listener to delete.
listener_name (String) —

The name of the listener to delete.

Example: example_listener
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1127

def delete_listener(load_balancer_id, listener_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_listener.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_listener." if load_balancer_id.nil?
  raise "Missing the required parameter 'listener_name' when calling delete_listener." if listener_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'listener_name' must not be blank" if OCI::Internal::Util.blank_string?(listener_name)

  path = '/loadBalancers/{loadBalancerId}/listeners/{listenerName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{listenerName}', listener_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_listener') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_load_balancer(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_load_balancer.rb.html) to see an example of how to use delete_load_balancer API.

Stops a load balancer and removes it from service.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer to delete.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1184

def delete_load_balancer(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_load_balancer.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_load_balancer." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_load_balancer') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_path_route_set(load_balancer_id, path_route_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_path_route_set.rb.html) to see an example of how to use delete_path_route_set API.

Deletes a path route set from the specified load balancer.

To delete a path route rule from a path route set, use the update_path_route_set operation.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the path route set to delete.
path_route_set_name (String) —

The name of the path route set to delete.

Example: example_path_route_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1247

def delete_path_route_set(load_balancer_id, path_route_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_path_route_set.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_path_route_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'path_route_set_name' when calling delete_path_route_set." if path_route_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'path_route_set_name' must not be blank" if OCI::Internal::Util.blank_string?(path_route_set_name)

  path = '/loadBalancers/{loadBalancerId}/pathRouteSets/{pathRouteSetName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{pathRouteSetName}', path_route_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_path_route_set') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_routing_policy(load_balancer_id, routing_policy_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_routing_policy.rb.html) to see an example of how to use delete_routing_policy API.

Deletes a routing policy from the specified load balancer.

To delete a routing rule from a routing policy, use the update_routing_policy operation.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the routing policy to delete.
routing_policy_name (String) —

The name of the routing policy to delete.

Example: example_routing_policy
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1312

def delete_routing_policy(load_balancer_id, routing_policy_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_routing_policy.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_routing_policy." if load_balancer_id.nil?
  raise "Missing the required parameter 'routing_policy_name' when calling delete_routing_policy." if routing_policy_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'routing_policy_name' must not be blank" if OCI::Internal::Util.blank_string?(routing_policy_name)

  path = '/loadBalancers/{loadBalancerId}/routingPolicies/{routingPolicyName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{routingPolicyName}', routing_policy_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_routing_policy') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_rule_set(load_balancer_id, rule_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_rule_set.rb.html) to see an example of how to use delete_rule_set API.

Deletes a rule set from the specified load balancer.

To delete a rule from a rule set, use the update_rule_set operation.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the specified load balancer.
rule_set_name (String) —

The name of the rule set to delete.

Example: example_rule_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1377

def delete_rule_set(load_balancer_id, rule_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_rule_set.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_rule_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'rule_set_name' when calling delete_rule_set." if rule_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'rule_set_name' must not be blank" if OCI::Internal::Util.blank_string?(rule_set_name)

  path = '/loadBalancers/{loadBalancerId}/ruleSets/{ruleSetName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{ruleSetName}', rule_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_rule_set') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#delete_ssl_cipher_suite(load_balancer_id, name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/delete_ssl_cipher_suite.rb.html) to see an example of how to use delete_ssl_cipher_suite API.

Deletes an SSL cipher suite from a load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the associated load balancer.
name (String) —

The name of the SSL cipher suite to delete.

example: example_cipher_suite
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1439

def delete_ssl_cipher_suite(load_balancer_id, name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#delete_ssl_cipher_suite.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling delete_ssl_cipher_suite." if load_balancer_id.nil?
  raise "Missing the required parameter 'name' when calling delete_ssl_cipher_suite." if name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'name' must not be blank" if OCI::Internal::Util.blank_string?(name)

  path = '/loadBalancers/{loadBalancerId}/sslCipherSuites/{name}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{name}', name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#delete_ssl_cipher_suite') do
    @api_client.call_api(
      :DELETE,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_backend(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_backend.rb.html) to see an example of how to use get_backend API.

Gets the specified backend server’s configuration information.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set and server.
backend_set_name (String) —

The name of the backend set that includes the backend server.

Example: example_backend_set
backend_name (String) —

The IP address and port of the backend server to retrieve.

Example: 10.0.0.3:8080
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type Backend

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1504

def get_backend(load_balancer_id, backend_set_name, backend_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_backend.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_backend." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling get_backend." if backend_set_name.nil?
  raise "Missing the required parameter 'backend_name' when calling get_backend." if backend_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)
  raise "Parameter value for 'backend_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends/{backendName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s).sub('{backendName}', backend_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_backend') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::Backend'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_backend_health(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_backend_health.rb.html) to see an example of how to use get_backend_health API.

Gets the current health status of the specified backend server.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend server health status to be retrieved.
backend_set_name (String) —

The name of the backend set associated with the backend server to retrieve the health status for.

Example: example_backend_set
backend_name (String) —

The IP address and port of the backend server to retrieve the health status for.

Example: 10.0.0.3:8080
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type BackendHealth

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1572

def get_backend_health(load_balancer_id, backend_set_name, backend_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_backend_health.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_backend_health." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling get_backend_health." if backend_set_name.nil?
  raise "Missing the required parameter 'backend_name' when calling get_backend_health." if backend_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)
  raise "Parameter value for 'backend_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends/{backendName}/health'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s).sub('{backendName}', backend_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_backend_health') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::BackendHealth'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_backend_set(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_backend_set.rb.html) to see an example of how to use get_backend_set API.

Gets the specified backend set’s configuration information.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the specified load balancer.
backend_set_name (String) —

The name of the backend set to retrieve.

Example: example_backend_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type BackendSet

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1636

def get_backend_set(load_balancer_id, backend_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_backend_set.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_backend_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling get_backend_set." if backend_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_backend_set') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::BackendSet'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_backend_set_health(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_backend_set_health.rb.html) to see an example of how to use get_backend_set_health API.

Gets the health status for the specified backend set.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set health status to be retrieved.
backend_set_name (String) —

The name of the backend set to retrieve the health status for.

Example: example_backend_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type BackendSetHealth

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1698

def get_backend_set_health(load_balancer_id, backend_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_backend_set_health.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_backend_set_health." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling get_backend_set_health." if backend_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/health'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_backend_set_health') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::BackendSetHealth'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_health_checker(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_health_checker.rb.html) to see an example of how to use get_health_checker API.

Gets the health check policy information for a given load balancer and backend set.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the health check policy to be retrieved.
backend_set_name (String) —

The name of the backend set associated with the health check policy to be retrieved.

Example: example_backend_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type HealthChecker

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1760

def get_health_checker(load_balancer_id, backend_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_health_checker.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_health_checker." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling get_health_checker." if backend_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/healthChecker'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_health_checker') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::HealthChecker'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_hostname(load_balancer_id, name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_hostname.rb.html) to see an example of how to use get_hostname API.

Gets the specified hostname resource’s configuration information.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the specified load balancer.
name (String) —

The name of the hostname resource to retrieve.

Example: example_hostname_001
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type Hostname

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1822

def get_hostname(load_balancer_id, name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_hostname.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_hostname." if load_balancer_id.nil?
  raise "Missing the required parameter 'name' when calling get_hostname." if name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'name' must not be blank" if OCI::Internal::Util.blank_string?(name)

  path = '/loadBalancers/{loadBalancerId}/hostnames/{name}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{name}', name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_hostname') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::Hostname'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_load_balancer(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_load_balancer.rb.html) to see an example of how to use get_load_balancer API.

Gets the specified load balancer’s configuration information.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer to retrieve.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type LoadBalancer

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1880

def get_load_balancer(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_load_balancer.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_load_balancer." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_load_balancer') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::LoadBalancer'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_load_balancer_health(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_load_balancer_health.rb.html) to see an example of how to use get_load_balancer_health API.

Gets the health status for the specified load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer to return health status for.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type LoadBalancerHealth

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1936

def get_load_balancer_health(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_load_balancer_health.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_load_balancer_health." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/health'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_load_balancer_health') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::LoadBalancerHealth'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_path_route_set(load_balancer_id, path_route_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_path_route_set.rb.html) to see an example of how to use get_path_route_set API.

Gets the specified path route set’s configuration information.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the specified load balancer.
path_route_set_name (String) —

The name of the path route set to retrieve.

Example: example_path_route_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type PathRouteSet

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 1996

def get_path_route_set(load_balancer_id, path_route_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_path_route_set.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_path_route_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'path_route_set_name' when calling get_path_route_set." if path_route_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'path_route_set_name' must not be blank" if OCI::Internal::Util.blank_string?(path_route_set_name)

  path = '/loadBalancers/{loadBalancerId}/pathRouteSets/{pathRouteSetName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{pathRouteSetName}', path_route_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_path_route_set') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::PathRouteSet'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_routing_policy(load_balancer_id, routing_policy_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_routing_policy.rb.html) to see an example of how to use get_routing_policy API.

Gets the specified routing policy.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the specified load balancer.
routing_policy_name (String) —

The name of the routing policy to retrieve.

Example: example_routing_policy
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type RoutingPolicy

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2058

def get_routing_policy(load_balancer_id, routing_policy_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_routing_policy.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_routing_policy." if load_balancer_id.nil?
  raise "Missing the required parameter 'routing_policy_name' when calling get_routing_policy." if routing_policy_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'routing_policy_name' must not be blank" if OCI::Internal::Util.blank_string?(routing_policy_name)

  path = '/loadBalancers/{loadBalancerId}/routingPolicies/{routingPolicyName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{routingPolicyName}', routing_policy_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_routing_policy') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::RoutingPolicy'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_rule_set(load_balancer_id, rule_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_rule_set.rb.html) to see an example of how to use get_rule_set API.

Gets the specified set of rules.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the specified load balancer.
rule_set_name (String) —

The name of the rule set to retrieve.

Example: example_rule_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type RuleSet

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2120

def get_rule_set(load_balancer_id, rule_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_rule_set.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_rule_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'rule_set_name' when calling get_rule_set." if rule_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'rule_set_name' must not be blank" if OCI::Internal::Util.blank_string?(rule_set_name)

  path = '/loadBalancers/{loadBalancerId}/ruleSets/{ruleSetName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{ruleSetName}', rule_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_rule_set') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::RuleSet'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_ssl_cipher_suite(load_balancer_id, name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_ssl_cipher_suite.rb.html) to see an example of how to use get_ssl_cipher_suite API.

Gets the specified SSL cipher suite’s configuration information.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the associated load balancer.
name (String) —

The name of the SSL cipher suite to retrieve.

example: example_cipher_suite
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type SSLCipherSuite

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2183

def get_ssl_cipher_suite(load_balancer_id, name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_ssl_cipher_suite.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling get_ssl_cipher_suite." if load_balancer_id.nil?
  raise "Missing the required parameter 'name' when calling get_ssl_cipher_suite." if name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'name' must not be blank" if OCI::Internal::Util.blank_string?(name)

  path = '/loadBalancers/{loadBalancerId}/sslCipherSuites/{name}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{name}', name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_ssl_cipher_suite') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::SSLCipherSuite'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#get_work_request(work_request_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/get_work_request.rb.html) to see an example of how to use get_work_request API.

Gets the details of a work request.

Parameters:

work_request_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the work request to retrieve.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type WorkRequest

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2241

def get_work_request(work_request_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#get_work_request.' if logger

  raise "Missing the required parameter 'work_request_id' when calling get_work_request." if work_request_id.nil?
  raise "Parameter value for 'work_request_id' must not be blank" if OCI::Internal::Util.blank_string?(work_request_id)

  path = '/loadBalancerWorkRequests/{workRequestId}'.sub('{workRequestId}', work_request_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#get_work_request') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'OCI::LoadBalancer::Models::WorkRequest'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_backend_sets(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_backend_sets.rb.html) to see an example of how to use list_backend_sets API.

Lists all backend sets associated with a given load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend sets to retrieve.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type Array<BackendSet>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2297

def list_backend_sets(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_backend_sets.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_backend_sets." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/backendSets'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_backend_sets') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::BackendSet>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_backends(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_backends.rb.html) to see an example of how to use list_backends API.

Lists the backend servers for a given load balancer and backend set.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set and servers.
backend_set_name (String) —

The name of the backend set associated with the backend servers.

Example: example_backend_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type Array<Backend>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2357

def list_backends(load_balancer_id, backend_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_backends.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_backends." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling list_backends." if backend_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_backends') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::Backend>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_certificates(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_certificates.rb.html) to see an example of how to use list_certificates API.

Lists all SSL certificates bundles associated with a given load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the certificate bundles to be listed.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type Array<Certificate>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2417

def list_certificates(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_certificates.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_certificates." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/certificates'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_certificates') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::Certificate>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_hostnames(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_hostnames.rb.html) to see an example of how to use list_hostnames API.

Lists all hostname resources associated with the specified load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the hostnames to retrieve.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type Array<Hostname>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2475

def list_hostnames(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_hostnames.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_hostnames." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/hostnames'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_hostnames') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::Hostname>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_listener_rules(load_balancer_id, listener_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_listener_rules.rb.html) to see an example of how to use list_listener_rules API.

Lists all of the rules from all of the rule sets associated with the specified listener. The response organizes the rules in the following order:

Access control rules
Allow method rules
Request header rules
Response header rules

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the listener.
listener_name (String) —

The name of the listener the rules are associated with.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type Array<ListenerRuleSummary>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2540

def list_listener_rules(load_balancer_id, listener_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_listener_rules.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_listener_rules." if load_balancer_id.nil?
  raise "Missing the required parameter 'listener_name' when calling list_listener_rules." if listener_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'listener_name' must not be blank" if OCI::Internal::Util.blank_string?(listener_name)

  path = '/loadBalancers/{loadBalancerId}/listeners/{listenerName}/rules'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{listenerName}', listener_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_listener_rules') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::ListenerRuleSummary>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_load_balancer_healths(compartment_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_load_balancer_healths.rb.html) to see an example of how to use list_load_balancer_healths API.

Lists the summary health statuses for all load balancers in the specified compartment.

Parameters:

compartment_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the compartment containing the load balancers to return health status information for.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:limit (Integer) —
For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 50
```
(default to 10)
```
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 3

Returns:

(Response) —

A Response object with data of type Array<LoadBalancerHealthSummary>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2608

def list_load_balancer_healths(compartment_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_load_balancer_healths.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_load_balancer_healths." if compartment_id.nil?

  path = '/loadBalancerHealths'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_load_balancer_healths') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::LoadBalancerHealthSummary>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_load_balancers(compartment_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_load_balancers.rb.html) to see an example of how to use list_load_balancers API.

Lists all load balancers in the specified compartment.

Parameters:

compartment_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the compartment containing the load balancers to list.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:limit (Integer) —
For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 50
```
(default to 10)
```
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 3
:detail (String) —
The level of detail to return for each result. Can be full or simple.

Example: full
```
(default to full)
```
:sort_by (String) —

The field to sort by. You can provide one sort order (sortOrder). Default order for TIMECREATED is descending. Default order for DISPLAYNAME is ascending. The DISPLAYNAME sort order is case sensitive.

Allowed values are: TIMECREATED, DISPLAYNAME
:sort_order (String) —

The sort order to use, either ascending (ASC) or descending (DESC). The DISPLAYNAME sort order is case sensitive.

Allowed values are: ASC, DESC
:display_name (String) —

A filter to return only resources that match the given display name exactly.

Example: example_load_balancer
:lifecycle_state (String) —

A filter to return only resources that match the given lifecycle state.

Example: SUCCEEDED

Returns:

(Response) —

A Response object with data of type Array<LoadBalancer>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2695

def list_load_balancers(compartment_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_load_balancers.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_load_balancers." if compartment_id.nil?

  if opts[:sort_by] && !%w[TIMECREATED DISPLAYNAME].include?(opts[:sort_by])
    raise 'Invalid value for "sort_by", must be one of TIMECREATED, DISPLAYNAME.'
  end

  if opts[:sort_order] && !%w[ASC DESC].include?(opts[:sort_order])
    raise 'Invalid value for "sort_order", must be one of ASC, DESC.'
  end

  if opts[:lifecycle_state] && !OCI::LoadBalancer::Models::LoadBalancer::LIFECYCLE_STATE_ENUM.include?(opts[:lifecycle_state])
    raise 'Invalid value for "lifecycle_state", must be one of the values in OCI::LoadBalancer::Models::LoadBalancer::LIFECYCLE_STATE_ENUM.'
  end

  path = '/loadBalancers'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]
  query_params[:detail] = opts[:detail] if opts[:detail]
  query_params[:sortBy] = opts[:sort_by] if opts[:sort_by]
  query_params[:sortOrder] = opts[:sort_order] if opts[:sort_order]
  query_params[:displayName] = opts[:display_name] if opts[:display_name]
  query_params[:lifecycleState] = opts[:lifecycle_state] if opts[:lifecycle_state]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_load_balancers') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::LoadBalancer>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_path_route_sets(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_path_route_sets.rb.html) to see an example of how to use list_path_route_sets API.

Lists all path route sets associated with the specified load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the path route sets to retrieve.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type Array<PathRouteSet>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2772

def list_path_route_sets(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_path_route_sets.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_path_route_sets." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/pathRouteSets'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_path_route_sets') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::PathRouteSet>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_policies(compartment_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_policies.rb.html) to see an example of how to use list_policies API.

Lists the available load balancer policies.

Parameters:

compartment_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the compartment containing the load balancer policies to list.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:limit (Integer) —
For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 50
```
(default to 16)
```
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 3

Returns:

(Response) —

A Response object with data of type Array<LoadBalancerPolicy>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2838

def list_policies(compartment_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_policies.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_policies." if compartment_id.nil?

  path = '/loadBalancerPolicies'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_policies') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::LoadBalancerPolicy>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_protocols(compartment_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_protocols.rb.html) to see an example of how to use list_protocols API.

Lists all supported traffic protocols.

Parameters:

compartment_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the compartment containing the load balancer protocols to list.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:limit (Integer) —
For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 50
```
(default to 16)
```
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 3

Returns:

(Response) —

A Response object with data of type Array<LoadBalancerProtocol>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2906

def list_protocols(compartment_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_protocols.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_protocols." if compartment_id.nil?

  path = '/loadBalancerProtocols'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_protocols') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::LoadBalancerProtocol>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_routing_policies(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_routing_policies.rb.html) to see an example of how to use list_routing_policies API.

Lists all routing policies associated with the specified load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the routing policies.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:limit (Integer) —
For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 50
```
(default to 10)
```
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 3

Returns:

(Response) —

A Response object with data of type Array<RoutingPolicy>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 2975

def list_routing_policies(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_routing_policies.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_routing_policies." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/routingPolicies'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_routing_policies') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::RoutingPolicy>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_rule_sets(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_rule_sets.rb.html) to see an example of how to use list_rule_sets API.

Lists all rule sets associated with the specified load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the specified load balancer.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type Array<RuleSet>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3033

def list_rule_sets(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_rule_sets.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_rule_sets." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/ruleSets'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_rule_sets') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::RuleSet>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_shapes(compartment_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_shapes.rb.html) to see an example of how to use list_shapes API.

Lists the valid load balancer shapes.

Parameters:

compartment_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the compartment containing the load balancer shapes to list.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:limit (Integer) —
For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 50
```
(default to 16)
```
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 3

Returns:

(Response) —

A Response object with data of type Array<LoadBalancerShape>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3099

def list_shapes(compartment_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_shapes.' if logger

  raise "Missing the required parameter 'compartment_id' when calling list_shapes." if compartment_id.nil?

  path = '/loadBalancerShapes'
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:compartmentId] = compartment_id
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_shapes') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::LoadBalancerShape>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_ssl_cipher_suites(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_ssl_cipher_suites.rb.html) to see an example of how to use list_ssl_cipher_suites API.

Lists all SSL cipher suites associated with the specified load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the associated load balancer.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.

Returns:

(Response) —

A Response object with data of type Array<SSLCipherSuite>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3158

def list_ssl_cipher_suites(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_ssl_cipher_suites.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_ssl_cipher_suites." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/sslCipherSuites'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_ssl_cipher_suites') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::SSLCipherSuite>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#list_work_requests(load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/list_work_requests.rb.html) to see an example of how to use list_work_requests API.

Lists the work requests for a given load balancer.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the work requests to retrieve.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:limit (Integer) —
For list pagination. The maximum number of results per page, or items to return in a paginated "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 50
```
(default to 100)
```
:page (String) —

For list pagination. The value of the opc-next-page response header from the previous "List" call. For important details about how pagination works, see [List Pagination](docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine).

Example: 3

Returns:

(Response) —

A Response object with data of type Array<WorkRequest>

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3224

def list_work_requests(load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#list_work_requests.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling list_work_requests." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/workRequests'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}
  query_params[:limit] = opts[:limit] if opts[:limit]
  query_params[:page] = opts[:page] if opts[:page]

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = nil

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#list_work_requests') do
    @api_client.call_api(
      :GET,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body,
      return_type: 'Array<OCI::LoadBalancer::Models::WorkRequest>'
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#logger ⇒ `Logger`

Returns The logger for this client. May be nil.

Returns:

(Logger) —

The logger for this client. May be nil.



93
94
95

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 93

def logger
  @api_client.config.logger
end

#update_backend(update_backend_details, load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_backend.rb.html) to see an example of how to use update_backend API.

Updates the configuration of a backend server within the specified backend set.

Parameters:

update_backend_details (OCI::LoadBalancer::Models::UpdateBackendDetails) —

Details for updating a backend server.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set and server.
backend_set_name (String) —

The name of the backend set associated with the backend server.

Example: example_backend_set
backend_name (String) —

The IP address and port of the backend server to update.

Example: 10.0.0.3:8080
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3297

def update_backend(update_backend_details, load_balancer_id, backend_set_name, backend_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_backend.' if logger

  raise "Missing the required parameter 'update_backend_details' when calling update_backend." if update_backend_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_backend." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling update_backend." if backend_set_name.nil?
  raise "Missing the required parameter 'backend_name' when calling update_backend." if backend_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)
  raise "Parameter value for 'backend_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends/{backendName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s).sub('{backendName}', backend_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_backend_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_backend') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_backend_set(update_backend_set_details, load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_backend_set.rb.html) to see an example of how to use update_backend_set API.

Updates a backend set.

Parameters:

update_backend_set_details (OCI::LoadBalancer::Models::UpdateBackendSetDetails) —

The details to update a backend set.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set.
backend_set_name (String) —

The name of the backend set to update.

Example: example_backend_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3370

def update_backend_set(update_backend_set_details, load_balancer_id, backend_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_backend_set.' if logger

  raise "Missing the required parameter 'update_backend_set_details' when calling update_backend_set." if update_backend_set_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_backend_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling update_backend_set." if backend_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_backend_set_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_backend_set') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_health_checker(health_checker, load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_health_checker.rb.html) to see an example of how to use update_health_checker API.

Updates the health check policy for a given load balancer and backend set.

Parameters:

health_checker (OCI::LoadBalancer::Models::UpdateHealthCheckerDetails) —

The health check policy configuration details.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the health check policy to be updated.
backend_set_name (String) —

The name of the backend set associated with the health check policy to be retrieved.

Example: example_backend_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3441

def update_health_checker(health_checker, load_balancer_id, backend_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_health_checker.' if logger

  raise "Missing the required parameter 'health_checker' when calling update_health_checker." if health_checker.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_health_checker." if load_balancer_id.nil?
  raise "Missing the required parameter 'backend_set_name' when calling update_health_checker." if backend_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'backend_set_name' must not be blank" if OCI::Internal::Util.blank_string?(backend_set_name)

  path = '/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/healthChecker'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{backendSetName}', backend_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(health_checker)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_health_checker') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_hostname(update_hostname_details, load_balancer_id, name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_hostname.rb.html) to see an example of how to use update_hostname API.

Overwrites an existing hostname resource on the specified load balancer. Use this operation to change a virtual hostname.

Parameters:

update_hostname_details (OCI::LoadBalancer::Models::UpdateHostnameDetails) —

The configuration details to update a virtual hostname.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the virtual hostname to update.
name (String) —

The name of the hostname resource to update.

Example: example_hostname_001
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3510

def update_hostname(update_hostname_details, load_balancer_id, name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_hostname.' if logger

  raise "Missing the required parameter 'update_hostname_details' when calling update_hostname." if update_hostname_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_hostname." if load_balancer_id.nil?
  raise "Missing the required parameter 'name' when calling update_hostname." if name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'name' must not be blank" if OCI::Internal::Util.blank_string?(name)

  path = '/loadBalancers/{loadBalancerId}/hostnames/{name}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{name}', name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(update_hostname_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_hostname') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_listener(update_listener_details, load_balancer_id, listener_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_listener.rb.html) to see an example of how to use update_listener API.

Updates a listener for a given load balancer.

Parameters:

update_listener_details (OCI::LoadBalancer::Models::UpdateListenerDetails) —

Details to update a listener.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the listener to update.
listener_name (String) —

The name of the listener to update.

Example: example_listener
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3579

def update_listener(update_listener_details, load_balancer_id, listener_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_listener.' if logger

  raise "Missing the required parameter 'update_listener_details' when calling update_listener." if update_listener_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_listener." if load_balancer_id.nil?
  raise "Missing the required parameter 'listener_name' when calling update_listener." if listener_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'listener_name' must not be blank" if OCI::Internal::Util.blank_string?(listener_name)

  path = '/loadBalancers/{loadBalancerId}/listeners/{listenerName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{listenerName}', listener_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_listener_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_listener') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_load_balancer(update_load_balancer_details, load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_load_balancer.rb.html) to see an example of how to use update_load_balancer API.

Updates a load balancer’s configuration.

Parameters:

update_load_balancer_details (OCI::LoadBalancer::Models::UpdateLoadBalancerDetails) —

The details for updating a load balancer’s configuration.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer to update.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3646

def update_load_balancer(update_load_balancer_details, load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_load_balancer.' if logger

  raise "Missing the required parameter 'update_load_balancer_details' when calling update_load_balancer." if update_load_balancer_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_load_balancer." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_load_balancer_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_load_balancer') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_load_balancer_shape(load_balancer_id, update_load_balancer_shape_details, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_load_balancer_shape.rb.html) to see an example of how to use update_load_balancer_shape API.

Update the shape of a load balancer. The new shape can be larger or smaller compared to existing shape of the LB. The service will try to perform this operation in the least disruptive way to existing connections, but there is a possibility that they might be lost during the LB resizing process. The new shape becomes effective as soon as the related work request completes successfully, i.e. when reshaping to a larger shape, the LB will start accepting larger bandwidth and when reshaping to a smaller one, the LB will be accepting smaller bandwidth.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer whose shape will be updated.
update_load_balancer_shape_details (OCI::LoadBalancer::Models::UpdateLoadBalancerShapeDetails) —

The details for updating a load balancer’s shape. This contains the new, desired shape.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3717

def update_load_balancer_shape(load_balancer_id, update_load_balancer_shape_details, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_load_balancer_shape.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling update_load_balancer_shape." if load_balancer_id.nil?
  raise "Missing the required parameter 'update_load_balancer_shape_details' when calling update_load_balancer_shape." if update_load_balancer_shape_details.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/updateShape'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_load_balancer_shape_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_load_balancer_shape') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_network_security_groups(update_network_security_groups_details, load_balancer_id, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_network_security_groups.rb.html) to see an example of how to use update_network_security_groups API.

Updates the network security groups associated with the specified load balancer.

Parameters:

update_network_security_groups_details (OCI::LoadBalancer::Models::UpdateNetworkSecurityGroupsDetails) —

The details for updating the NSGs associated with the specified load balancer.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer to update the NSGs for.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3782

def update_network_security_groups(update_network_security_groups_details, load_balancer_id, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_network_security_groups.' if logger

  raise "Missing the required parameter 'update_network_security_groups_details' when calling update_network_security_groups." if update_network_security_groups_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_network_security_groups." if load_balancer_id.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)

  path = '/loadBalancers/{loadBalancerId}/networkSecurityGroups'.sub('{loadBalancerId}', load_balancer_id.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_network_security_groups_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_network_security_groups') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_path_route_set(update_path_route_set_details, load_balancer_id, path_route_set_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_path_route_set.rb.html) to see an example of how to use update_path_route_set API.

Overwrites an existing path route set on the specified load balancer. Use this operation to add, delete, or alter path route rules in a path route set.

To add a new path route rule to a path route set, the pathRoutes in the update_path_route_set_details object must include both the new path route rule to add and the existing path route rules to retain.

Parameters:

update_path_route_set_details (OCI::LoadBalancer::Models::UpdatePathRouteSetDetails) —

The configuration details to update a path route set.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the path route set to update.
path_route_set_name (String) —

The name of the path route set to update.

Example: example_path_route_set
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3857

def update_path_route_set(update_path_route_set_details, load_balancer_id, path_route_set_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_path_route_set.' if logger

  raise "Missing the required parameter 'update_path_route_set_details' when calling update_path_route_set." if update_path_route_set_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_path_route_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'path_route_set_name' when calling update_path_route_set." if path_route_set_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'path_route_set_name' must not be blank" if OCI::Internal::Util.blank_string?(path_route_set_name)

  path = '/loadBalancers/{loadBalancerId}/pathRouteSets/{pathRouteSetName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{pathRouteSetName}', path_route_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_path_route_set_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_path_route_set') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_routing_policy(update_routing_policy_details, load_balancer_id, routing_policy_name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_routing_policy.rb.html) to see an example of how to use update_routing_policy API.

Overwrites an existing routing policy on the specified load balancer. Use this operation to add, delete, or alter routing policy rules in a routing policy.

To add a new routing rule to a routing policy, the body must include both the new routing rule to add and the existing rules to retain.

Parameters:

update_routing_policy_details (OCI::LoadBalancer::Models::UpdateRoutingPolicyDetails) —

The configuration details needed to update a routing policy.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the load balancer associated with the routing policy to update.
routing_policy_name (String) —

The name of the routing policy to update.

Example: example_routing_policy_name
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 3932

def update_routing_policy(update_routing_policy_details, load_balancer_id, routing_policy_name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_routing_policy.' if logger

  raise "Missing the required parameter 'update_routing_policy_details' when calling update_routing_policy." if update_routing_policy_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_routing_policy." if load_balancer_id.nil?
  raise "Missing the required parameter 'routing_policy_name' when calling update_routing_policy." if routing_policy_name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'routing_policy_name' must not be blank" if OCI::Internal::Util.blank_string?(routing_policy_name)

  path = '/loadBalancers/{loadBalancerId}/routingPolicies/{routingPolicyName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{routingPolicyName}', routing_policy_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_routing_policy_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_routing_policy') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_rule_set(load_balancer_id, rule_set_name, update_rule_set_details, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_rule_set.rb.html) to see an example of how to use update_rule_set API.

Overwrites an existing set of rules on the specified load balancer. Use this operation to add or alter the rules in a rule set.

To add a new rule to a set, the body must include both the new rule to add and the existing rules to retain.

Parameters:

load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the specified load balancer.
rule_set_name (String) —

The name of the rule set to update.

Example: example_rule_set
update_rule_set_details (OCI::LoadBalancer::Models::UpdateRuleSetDetails) —

The configuration details to update a set of rules.
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
```
(default to )
```

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 4001

def update_rule_set(load_balancer_id, rule_set_name, update_rule_set_details, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_rule_set.' if logger

  raise "Missing the required parameter 'load_balancer_id' when calling update_rule_set." if load_balancer_id.nil?
  raise "Missing the required parameter 'rule_set_name' when calling update_rule_set." if rule_set_name.nil?
  raise "Missing the required parameter 'update_rule_set_details' when calling update_rule_set." if update_rule_set_details.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'rule_set_name' must not be blank" if OCI::Internal::Util.blank_string?(rule_set_name)

  path = '/loadBalancers/{loadBalancerId}/ruleSets/{ruleSetName}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{ruleSetName}', rule_set_name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  # rubocop:enable Style/NegatedIf

  post_body = @api_client.object_to_http_body(update_rule_set_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_rule_set') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

#update_ssl_cipher_suite(update_ssl_cipher_suite_details, load_balancer_id, name, opts = {}) ⇒ `Response`

Note:

Click [here](docs.cloud.oracle.com/en-us/iaas/tools/ruby-sdk-examples/latest/loadbalancer/update_ssl_cipher_suite.rb.html) to see an example of how to use update_ssl_cipher_suite API.

Updates an existing SSL cipher suite for the specified load balancer.

Parameters:

update_ssl_cipher_suite_details (OCI::LoadBalancer::Models::UpdateSSLCipherSuiteDetails) —

The configuration details to update an SSL cipher suite.
load_balancer_id (String) —

The [OCID](docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the associated load balancer.
name (String) —

The name of the SSL cipher suite to update.

example: example_cipher_suite
opts (Hash) (defaults to: {}) —

the optional parameters

Options Hash (opts):

:retry_config (OCI::Retry::RetryConfig) —

The retry configuration to apply to this operation. If no key is provided then the service-level retry configuration defined by #retry_config will be used. If an explicit nil value is provided then the operation will not retry
:opc_request_id (String) —

Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:opc_retry_token (String) —

A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).

Returns:

(Response) —

A Response object with data of type nil

# File 'lib/oci/load_balancer/load_balancer_client.rb', line 4071

def update_ssl_cipher_suite(update_ssl_cipher_suite_details, load_balancer_id, name, opts = {})
  logger.debug 'Calling operation LoadBalancerClient#update_ssl_cipher_suite.' if logger

  raise "Missing the required parameter 'update_ssl_cipher_suite_details' when calling update_ssl_cipher_suite." if update_ssl_cipher_suite_details.nil?
  raise "Missing the required parameter 'load_balancer_id' when calling update_ssl_cipher_suite." if load_balancer_id.nil?
  raise "Missing the required parameter 'name' when calling update_ssl_cipher_suite." if name.nil?
  raise "Parameter value for 'load_balancer_id' must not be blank" if OCI::Internal::Util.blank_string?(load_balancer_id)
  raise "Parameter value for 'name' must not be blank" if OCI::Internal::Util.blank_string?(name)

  path = '/loadBalancers/{loadBalancerId}/sslCipherSuites/{name}'.sub('{loadBalancerId}', load_balancer_id.to_s).sub('{name}', name.to_s)
  operation_signing_strategy = :standard

  # rubocop:disable Style/NegatedIf
  # Query Params
  query_params = {}

  # Header Params
  header_params = {}
  header_params[:accept] = 'application/json'
  header_params[:'content-type'] = 'application/json'
  header_params[:'opc-request-id'] = opts[:opc_request_id] if opts[:opc_request_id]
  header_params[:'opc-retry-token'] = opts[:opc_retry_token] if opts[:opc_retry_token]
  # rubocop:enable Style/NegatedIf
  header_params[:'opc-retry-token'] ||= OCI::Retry.generate_opc_retry_token

  post_body = @api_client.object_to_http_body(update_ssl_cipher_suite_details)

  # rubocop:disable Metrics/BlockLength
  OCI::Retry.make_retrying_call(applicable_retry_config(opts), call_name: 'LoadBalancerClient#update_ssl_cipher_suite') do
    @api_client.call_api(
      :PUT,
      path,
      endpoint,
      header_params: header_params,
      query_params: query_params,
      operation_signing_strategy: operation_signing_strategy,
      body: post_body
    )
  end
  # rubocop:enable Metrics/BlockLength
end

Class: OCI::LoadBalancer::LoadBalancerClient

Overview

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil) ⇒ LoadBalancerClient

Instance Attribute Details

#api_client ⇒ OCI::ApiClient (readonly)

#endpoint ⇒ String (readonly)

#region ⇒ String

#retry_config ⇒ OCI::Retry::RetryConfig (readonly)

Instance Method Details

#change_load_balancer_compartment(load_balancer_id, change_load_balancer_compartment_details, opts = {}) ⇒ Response

#create_backend(create_backend_details, load_balancer_id, backend_set_name, opts = {}) ⇒ Response

#create_backend_set(create_backend_set_details, load_balancer_id, opts = {}) ⇒ Response

#create_certificate(create_certificate_details, load_balancer_id, opts = {}) ⇒ Response

#create_hostname(create_hostname_details, load_balancer_id, opts = {}) ⇒ Response

#create_listener(create_listener_details, load_balancer_id, opts = {}) ⇒ Response

#create_load_balancer(create_load_balancer_details, opts = {}) ⇒ Response

#create_path_route_set(create_path_route_set_details, load_balancer_id, opts = {}) ⇒ Response

#create_routing_policy(create_routing_policy_details, load_balancer_id, opts = {}) ⇒ Response

#create_rule_set(load_balancer_id, create_rule_set_details, opts = {}) ⇒ Response

#create_ssl_cipher_suite(create_ssl_cipher_suite_details, load_balancer_id, opts = {}) ⇒ Response

#delete_backend(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ Response

#delete_backend_set(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

#delete_certificate(load_balancer_id, certificate_name, opts = {}) ⇒ Response

#delete_hostname(load_balancer_id, name, opts = {}) ⇒ Response

#delete_listener(load_balancer_id, listener_name, opts = {}) ⇒ Response

#delete_load_balancer(load_balancer_id, opts = {}) ⇒ Response

#delete_path_route_set(load_balancer_id, path_route_set_name, opts = {}) ⇒ Response

#delete_routing_policy(load_balancer_id, routing_policy_name, opts = {}) ⇒ Response

#delete_rule_set(load_balancer_id, rule_set_name, opts = {}) ⇒ Response

#delete_ssl_cipher_suite(load_balancer_id, name, opts = {}) ⇒ Response

#get_backend(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ Response

#get_backend_health(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ Response

#get_backend_set(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

#get_backend_set_health(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

#get_health_checker(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

#get_hostname(load_balancer_id, name, opts = {}) ⇒ Response

#get_load_balancer(load_balancer_id, opts = {}) ⇒ Response

#get_load_balancer_health(load_balancer_id, opts = {}) ⇒ Response

#get_path_route_set(load_balancer_id, path_route_set_name, opts = {}) ⇒ Response

#get_routing_policy(load_balancer_id, routing_policy_name, opts = {}) ⇒ Response

#get_rule_set(load_balancer_id, rule_set_name, opts = {}) ⇒ Response

#get_ssl_cipher_suite(load_balancer_id, name, opts = {}) ⇒ Response

#get_work_request(work_request_id, opts = {}) ⇒ Response

#list_backend_sets(load_balancer_id, opts = {}) ⇒ Response

#list_backends(load_balancer_id, backend_set_name, opts = {}) ⇒ Response

#list_certificates(load_balancer_id, opts = {}) ⇒ Response

#list_hostnames(load_balancer_id, opts = {}) ⇒ Response

#list_listener_rules(load_balancer_id, listener_name, opts = {}) ⇒ Response

#list_load_balancer_healths(compartment_id, opts = {}) ⇒ Response

#list_load_balancers(compartment_id, opts = {}) ⇒ Response

#list_path_route_sets(load_balancer_id, opts = {}) ⇒ Response

#list_policies(compartment_id, opts = {}) ⇒ Response

#list_protocols(compartment_id, opts = {}) ⇒ Response

#list_routing_policies(load_balancer_id, opts = {}) ⇒ Response

#list_rule_sets(load_balancer_id, opts = {}) ⇒ Response

#list_shapes(compartment_id, opts = {}) ⇒ Response

#list_ssl_cipher_suites(load_balancer_id, opts = {}) ⇒ Response

#list_work_requests(load_balancer_id, opts = {}) ⇒ Response

#logger ⇒ Logger

#update_backend(update_backend_details, load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ Response

#update_backend_set(update_backend_set_details, load_balancer_id, backend_set_name, opts = {}) ⇒ Response

#update_health_checker(health_checker, load_balancer_id, backend_set_name, opts = {}) ⇒ Response

#update_hostname(update_hostname_details, load_balancer_id, name, opts = {}) ⇒ Response

#update_listener(update_listener_details, load_balancer_id, listener_name, opts = {}) ⇒ Response

#update_load_balancer(update_load_balancer_details, load_balancer_id, opts = {}) ⇒ Response

#update_load_balancer_shape(load_balancer_id, update_load_balancer_shape_details, opts = {}) ⇒ Response

#update_network_security_groups(update_network_security_groups_details, load_balancer_id, opts = {}) ⇒ Response

#update_path_route_set(update_path_route_set_details, load_balancer_id, path_route_set_name, opts = {}) ⇒ Response

#update_routing_policy(update_routing_policy_details, load_balancer_id, routing_policy_name, opts = {}) ⇒ Response

#update_rule_set(load_balancer_id, rule_set_name, update_rule_set_details, opts = {}) ⇒ Response

#update_ssl_cipher_suite(update_ssl_cipher_suite_details, load_balancer_id, name, opts = {}) ⇒ Response

#initialize(config: nil, region: nil, endpoint: nil, signer: nil, proxy_settings: nil, retry_config: nil) ⇒ `LoadBalancerClient`

#api_client ⇒ `OCI::ApiClient` (readonly)

#endpoint ⇒ `String` (readonly)

#region ⇒ `String`

#retry_config ⇒ `OCI::Retry::RetryConfig` (readonly)

#change_load_balancer_compartment(load_balancer_id, change_load_balancer_compartment_details, opts = {}) ⇒ `Response`

#create_backend(create_backend_details, load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

#create_backend_set(create_backend_set_details, load_balancer_id, opts = {}) ⇒ `Response`

#create_certificate(create_certificate_details, load_balancer_id, opts = {}) ⇒ `Response`

#create_hostname(create_hostname_details, load_balancer_id, opts = {}) ⇒ `Response`

#create_listener(create_listener_details, load_balancer_id, opts = {}) ⇒ `Response`

#create_load_balancer(create_load_balancer_details, opts = {}) ⇒ `Response`

#create_path_route_set(create_path_route_set_details, load_balancer_id, opts = {}) ⇒ `Response`

#create_routing_policy(create_routing_policy_details, load_balancer_id, opts = {}) ⇒ `Response`

#create_rule_set(load_balancer_id, create_rule_set_details, opts = {}) ⇒ `Response`

#create_ssl_cipher_suite(create_ssl_cipher_suite_details, load_balancer_id, opts = {}) ⇒ `Response`

#delete_backend(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ `Response`

#delete_backend_set(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

#delete_certificate(load_balancer_id, certificate_name, opts = {}) ⇒ `Response`

#delete_hostname(load_balancer_id, name, opts = {}) ⇒ `Response`

#delete_listener(load_balancer_id, listener_name, opts = {}) ⇒ `Response`

#delete_load_balancer(load_balancer_id, opts = {}) ⇒ `Response`

#delete_path_route_set(load_balancer_id, path_route_set_name, opts = {}) ⇒ `Response`

#delete_routing_policy(load_balancer_id, routing_policy_name, opts = {}) ⇒ `Response`

#delete_rule_set(load_balancer_id, rule_set_name, opts = {}) ⇒ `Response`

#delete_ssl_cipher_suite(load_balancer_id, name, opts = {}) ⇒ `Response`

#get_backend(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ `Response`

#get_backend_health(load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ `Response`

#get_backend_set(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

#get_backend_set_health(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

#get_health_checker(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

#get_hostname(load_balancer_id, name, opts = {}) ⇒ `Response`

#get_load_balancer(load_balancer_id, opts = {}) ⇒ `Response`

#get_load_balancer_health(load_balancer_id, opts = {}) ⇒ `Response`

#get_path_route_set(load_balancer_id, path_route_set_name, opts = {}) ⇒ `Response`

#get_routing_policy(load_balancer_id, routing_policy_name, opts = {}) ⇒ `Response`

#get_rule_set(load_balancer_id, rule_set_name, opts = {}) ⇒ `Response`

#get_ssl_cipher_suite(load_balancer_id, name, opts = {}) ⇒ `Response`

#get_work_request(work_request_id, opts = {}) ⇒ `Response`

#list_backend_sets(load_balancer_id, opts = {}) ⇒ `Response`

#list_backends(load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

#list_certificates(load_balancer_id, opts = {}) ⇒ `Response`

#list_hostnames(load_balancer_id, opts = {}) ⇒ `Response`

#list_listener_rules(load_balancer_id, listener_name, opts = {}) ⇒ `Response`

#list_load_balancer_healths(compartment_id, opts = {}) ⇒ `Response`

#list_load_balancers(compartment_id, opts = {}) ⇒ `Response`

#list_path_route_sets(load_balancer_id, opts = {}) ⇒ `Response`

#list_policies(compartment_id, opts = {}) ⇒ `Response`

#list_protocols(compartment_id, opts = {}) ⇒ `Response`

#list_routing_policies(load_balancer_id, opts = {}) ⇒ `Response`

#list_rule_sets(load_balancer_id, opts = {}) ⇒ `Response`

#list_shapes(compartment_id, opts = {}) ⇒ `Response`

#list_ssl_cipher_suites(load_balancer_id, opts = {}) ⇒ `Response`

#list_work_requests(load_balancer_id, opts = {}) ⇒ `Response`

#logger ⇒ `Logger`

#update_backend(update_backend_details, load_balancer_id, backend_set_name, backend_name, opts = {}) ⇒ `Response`

#update_backend_set(update_backend_set_details, load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

#update_health_checker(health_checker, load_balancer_id, backend_set_name, opts = {}) ⇒ `Response`

#update_hostname(update_hostname_details, load_balancer_id, name, opts = {}) ⇒ `Response`

#update_listener(update_listener_details, load_balancer_id, listener_name, opts = {}) ⇒ `Response`

#update_load_balancer(update_load_balancer_details, load_balancer_id, opts = {}) ⇒ `Response`

#update_load_balancer_shape(load_balancer_id, update_load_balancer_shape_details, opts = {}) ⇒ `Response`

#update_network_security_groups(update_network_security_groups_details, load_balancer_id, opts = {}) ⇒ `Response`

#update_path_route_set(update_path_route_set_details, load_balancer_id, path_route_set_name, opts = {}) ⇒ `Response`

#update_routing_policy(update_routing_policy_details, load_balancer_id, routing_policy_name, opts = {}) ⇒ `Response`

#update_rule_set(load_balancer_id, rule_set_name, update_rule_set_details, opts = {}) ⇒ `Response`

#update_ssl_cipher_suite(update_ssl_cipher_suite_details, load_balancer_id, name, opts = {}) ⇒ `Response`