LoadBalancerClientCompositeOperations¶

class oci.load_balancer.LoadBalancerClientCompositeOperations(client, **kwargs)¶

This class provides a wrapper around LoadBalancerClient and offers convenience methods for operations that would otherwise need to be chained together. For example, instead of performing an action on a resource (e.g. launching an instance, creating a load balancer) and then using a waiter to wait for the resource to enter a given state, you can call a single method in this class to accomplish the same functionality

Methods:

`__init__`(client, **kwargs)	Creates a new LoadBalancerClientCompositeOperations object
`change_load_balancer_compartment_and_wait_for_state`(...)	Calls `change_load_balancer_compartment()` and waits for the `WorkRequest` to enter the given state(s).
`create_backend_and_wait_for_state`(...[, ...])	Calls `create_backend()` and waits for the `WorkRequest` to enter the given state(s).
`create_backend_set_and_wait_for_state`(...[, ...])	Calls `create_backend_set()` and waits for the `WorkRequest` to enter the given state(s).
`create_certificate_and_wait_for_state`(...[, ...])	Calls `create_certificate()` and waits for the `WorkRequest` to enter the given state(s).
`create_hostname_and_wait_for_state`(...[, ...])	Calls `create_hostname()` and waits for the `WorkRequest` to enter the given state(s).
`create_listener_and_wait_for_state`(...[, ...])	Calls `create_listener()` and waits for the `WorkRequest` to enter the given state(s).
`create_load_balancer_and_wait_for_state`(...)	Calls `create_load_balancer()` and waits for the `WorkRequest` to enter the given state(s).
`create_path_route_set_and_wait_for_state`(...)	Calls `create_path_route_set()` and waits for the `WorkRequest` to enter the given state(s).
`create_routing_policy_and_wait_for_state`(...)	Calls `create_routing_policy()` and waits for the `WorkRequest` to enter the given state(s).
`create_rule_set_and_wait_for_state`(...[, ...])	Calls `create_rule_set()` and waits for the `WorkRequest` to enter the given state(s).
`create_ssl_cipher_suite_and_wait_for_state`(...)	Calls `create_ssl_cipher_suite()` and waits for the `WorkRequest` to enter the given state(s).
`delete_backend_and_wait_for_state`(...[, ...])	Calls `delete_backend()` and waits for the `WorkRequest` to enter the given state(s).
`delete_backend_set_and_wait_for_state`(...[, ...])	Calls `delete_backend_set()` and waits for the `WorkRequest` to enter the given state(s).
`delete_certificate_and_wait_for_state`(...[, ...])	Calls `delete_certificate()` and waits for the `WorkRequest` to enter the given state(s).
`delete_hostname_and_wait_for_state`(...[, ...])	Calls `delete_hostname()` and waits for the `WorkRequest` to enter the given state(s).
`delete_listener_and_wait_for_state`(...[, ...])	Calls `delete_listener()` and waits for the `WorkRequest` to enter the given state(s).
`delete_load_balancer_and_wait_for_state`(...)	Calls `delete_load_balancer()` and waits for the `WorkRequest` to enter the given state(s).
`delete_path_route_set_and_wait_for_state`(...)	Calls `delete_path_route_set()` and waits for the `WorkRequest` to enter the given state(s).
`delete_routing_policy_and_wait_for_state`(...)	Calls `delete_routing_policy()` and waits for the `WorkRequest` to enter the given state(s).
`delete_rule_set_and_wait_for_state`(...[, ...])	Calls `delete_rule_set()` and waits for the `WorkRequest` to enter the given state(s).
`delete_ssl_cipher_suite_and_wait_for_state`(...)	Calls `delete_ssl_cipher_suite()` and waits for the `WorkRequest` to enter the given state(s).
`update_backend_and_wait_for_state`(...[, ...])	Calls `update_backend()` and waits for the `WorkRequest` to enter the given state(s).
`update_backend_set_and_wait_for_state`(...[, ...])	Calls `update_backend_set()` and waits for the `WorkRequest` to enter the given state(s).
`update_health_checker_and_wait_for_state`(...)	Calls `update_health_checker()` and waits for the `WorkRequest` to enter the given state(s).
`update_hostname_and_wait_for_state`(...[, ...])	Calls `update_hostname()` and waits for the `WorkRequest` to enter the given state(s).
`update_listener_and_wait_for_state`(...[, ...])	Calls `update_listener()` and waits for the `WorkRequest` to enter the given state(s).
`update_load_balancer_and_wait_for_state`(...)	Calls `update_load_balancer()` and waits for the `WorkRequest` to enter the given state(s).
`update_load_balancer_shape_and_wait_for_state`(...)	Calls `update_load_balancer_shape()` and waits for the `WorkRequest` to enter the given state(s).
`update_network_security_groups_and_wait_for_state`(...)	Calls `update_network_security_groups()` and waits for the `WorkRequest` to enter the given state(s).
`update_path_route_set_and_wait_for_state`(...)	Calls `update_path_route_set()` and waits for the `WorkRequest` to enter the given state(s).
`update_routing_policy_and_wait_for_state`(...)	Calls `update_routing_policy()` and waits for the `WorkRequest` to enter the given state(s).
`update_rule_set_and_wait_for_state`(...[, ...])	Calls `update_rule_set()` and waits for the `WorkRequest` to enter the given state(s).
`update_ssl_cipher_suite_and_wait_for_state`(...)	Calls `update_ssl_cipher_suite()` and waits for the `WorkRequest` to enter the given state(s).

__init__(client, **kwargs)¶

Creates a new LoadBalancerClientCompositeOperations object

Parameters: client (LoadBalancerClient) – The service client which will be wrapped by this object

change_load_balancer_compartment_and_wait_for_state(load_balancer_id, change_load_balancer_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls change_load_balancer_compartment() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer to move.
change_load_balancer_compartment_details (oci.load_balancer.models.ChangeLoadBalancerCompartmentDetails) – (required) The configuration details for moving a load balancer to a different compartment.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to change_load_balancer_compartment()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_backend_and_wait_for_state(create_backend_details, load_balancer_id, backend_set_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_backend() and waits for the WorkRequest to enter the given state(s).

Parameters

create_backend_details (oci.load_balancer.models.CreateBackendDetails) – (required) The details to add a backend server to a backend set.
load_balancer_id (str) –
(required) The OCID of the load balancer associated with the backend set and servers.
backend_set_name (str) –
(required) The name of the backend set to add the backend server to.

Example: example_backend_set
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_backend()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_backend_set_and_wait_for_state(create_backend_set_details, load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_backend_set() and waits for the WorkRequest to enter the given state(s).

Parameters

create_backend_set_details (oci.load_balancer.models.CreateBackendSetDetails) – (required) The details for adding a backend set.
load_balancer_id (str) –
(required) The OCID of the load balancer on which to add a backend set.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_backend_set()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_certificate_and_wait_for_state(create_certificate_details, load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_certificate() and waits for the WorkRequest to enter the given state(s).

Parameters

create_certificate_details (oci.load_balancer.models.CreateCertificateDetails) – (required) The details of the certificate bundle to add.
load_balancer_id (str) –
(required) The OCID of the load balancer on which to add the certificate bundle.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_certificate()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_hostname_and_wait_for_state(create_hostname_details, load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_hostname() and waits for the WorkRequest to enter the given state(s).

Parameters

create_hostname_details (oci.load_balancer.models.CreateHostnameDetails) – (required) The details of the hostname resource to add to the specified load balancer.
load_balancer_id (str) –
(required) The OCID of the load balancer to add the hostname to.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_hostname()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_listener_and_wait_for_state(create_listener_details, load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_listener() and waits for the WorkRequest to enter the given state(s).

Parameters

create_listener_details (oci.load_balancer.models.CreateListenerDetails) – (required) Details to add a listener.
load_balancer_id (str) –
(required) The OCID of the load balancer on which to add a listener.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_listener()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_load_balancer_and_wait_for_state(create_load_balancer_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_load_balancer() and waits for the WorkRequest to enter the given state(s).

Parameters

create_load_balancer_details (oci.load_balancer.models.CreateLoadBalancerDetails) – (required) The configuration details for creating a load balancer.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_load_balancer()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_path_route_set_and_wait_for_state(create_path_route_set_details, load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_path_route_set() and waits for the WorkRequest to enter the given state(s).

Parameters

create_path_route_set_details (oci.load_balancer.models.CreatePathRouteSetDetails) – (required) The details of the path route set to add.
load_balancer_id (str) –
(required) The OCID of the load balancer to add the path route set to.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_path_route_set()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_routing_policy_and_wait_for_state(create_routing_policy_details, load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_routing_policy() and waits for the WorkRequest to enter the given state(s).

Parameters

create_routing_policy_details (oci.load_balancer.models.CreateRoutingPolicyDetails) – (required) The details of the routing policy rules to add.
load_balancer_id (str) –
(required) The OCID of the load balancer to add the routing policy rule list to.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_routing_policy()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_rule_set_and_wait_for_state(load_balancer_id, create_rule_set_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_rule_set() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the specified load balancer.
create_rule_set_details (oci.load_balancer.models.CreateRuleSetDetails) – (required) The configuration details for the rule set to create.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_rule_set()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

create_ssl_cipher_suite_and_wait_for_state(create_ssl_cipher_suite_details, load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls create_ssl_cipher_suite() and waits for the WorkRequest to enter the given state(s).

Parameters

create_ssl_cipher_suite_details (oci.load_balancer.models.CreateSSLCipherSuiteDetails) – (required) The details of the SSL cipher suite to add.
load_balancer_id (str) –
(required) The OCID of the associated load balancer.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to create_ssl_cipher_suite()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_backend_and_wait_for_state(load_balancer_id, backend_set_name, backend_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_backend() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer associated with the backend set and server.
backend_set_name (str) –
(required) The name of the backend set associated with the backend server.

Example: example_backend_set
backend_name (str) –
(required) The IP address and port of the backend server to remove.

Example: 10.0.0.3:8080
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_backend()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_backend_set_and_wait_for_state(load_balancer_id, backend_set_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_backend_set() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer associated with the backend set.
backend_set_name (str) –
(required) The name of the backend set to delete.

Example: example_backend_set
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_backend_set()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_certificate_and_wait_for_state(load_balancer_id, certificate_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_certificate() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer associated with the certificate bundle to be deleted.
certificate_name (str) –
(required) The name of the certificate bundle to delete.

Example: example_certificate_bundle
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_certificate()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_hostname_and_wait_for_state(load_balancer_id, name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_hostname() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer associated with the hostname to delete.
name (str) –
(required) The name of the hostname resource to delete.

Example: example_hostname_001
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_hostname()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_listener_and_wait_for_state(load_balancer_id, listener_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_listener() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer associated with the listener to delete.
listener_name (str) –
(required) The name of the listener to delete.

Example: example_listener
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_listener()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_load_balancer_and_wait_for_state(load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_load_balancer() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer to delete.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_load_balancer()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_path_route_set_and_wait_for_state(load_balancer_id, path_route_set_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_path_route_set() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer associated with the path route set to delete.
path_route_set_name (str) –
(required) The name of the path route set to delete.

Example: example_path_route_set
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_path_route_set()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_routing_policy_and_wait_for_state(load_balancer_id, routing_policy_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_routing_policy() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer associated with the routing policy to delete.
routing_policy_name (str) –
(required) The name of the routing policy to delete.

Example: example_routing_policy
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_routing_policy()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_rule_set_and_wait_for_state(load_balancer_id, rule_set_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_rule_set() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the specified load balancer.
rule_set_name (str) –
(required) The name of the rule set to delete.

Example: example_rule_set
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_rule_set()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

delete_ssl_cipher_suite_and_wait_for_state(load_balancer_id, name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls delete_ssl_cipher_suite() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the associated load balancer.
name (str) –
(required) The name of the SSL cipher suite to delete.

example: example_cipher_suite
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to delete_ssl_cipher_suite()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_backend_and_wait_for_state(update_backend_details, load_balancer_id, backend_set_name, backend_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_backend() and waits for the WorkRequest to enter the given state(s).

Parameters

update_backend_details (oci.load_balancer.models.UpdateBackendDetails) – (required) Details for updating a backend server.
load_balancer_id (str) –
(required) The OCID of the load balancer associated with the backend set and server.
backend_set_name (str) –
(required) The name of the backend set associated with the backend server.

Example: example_backend_set
backend_name (str) –
(required) The IP address and port of the backend server to update.

Example: 10.0.0.3:8080
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_backend()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_backend_set_and_wait_for_state(update_backend_set_details, load_balancer_id, backend_set_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_backend_set() and waits for the WorkRequest to enter the given state(s).

Parameters

update_backend_set_details (oci.load_balancer.models.UpdateBackendSetDetails) – (required) The details to update a backend set.
load_balancer_id (str) –
(required) The OCID of the load balancer associated with the backend set.
backend_set_name (str) –
(required) The name of the backend set to update.

Example: example_backend_set
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_backend_set()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_health_checker_and_wait_for_state(health_checker, load_balancer_id, backend_set_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_health_checker() and waits for the WorkRequest to enter the given state(s).

Parameters

health_checker (oci.load_balancer.models.UpdateHealthCheckerDetails) – (required) The health check policy configuration details.
load_balancer_id (str) –
(required) The OCID of the load balancer associated with the health check policy to be updated.
backend_set_name (str) –
(required) The name of the backend set associated with the health check policy to be retrieved.

Example: example_backend_set
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_health_checker()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_hostname_and_wait_for_state(update_hostname_details, load_balancer_id, name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_hostname() and waits for the WorkRequest to enter the given state(s).

Parameters

update_hostname_details (oci.load_balancer.models.UpdateHostnameDetails) – (required) The configuration details to update a virtual hostname.
load_balancer_id (str) –
(required) The OCID of the load balancer associated with the virtual hostname to update.
name (str) –
(required) The name of the hostname resource to update.

Example: example_hostname_001
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_hostname()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_listener_and_wait_for_state(update_listener_details, load_balancer_id, listener_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_listener() and waits for the WorkRequest to enter the given state(s).

Parameters

update_listener_details (oci.load_balancer.models.UpdateListenerDetails) – (required) Details to update a listener.
load_balancer_id (str) –
(required) The OCID of the load balancer associated with the listener to update.
listener_name (str) –
(required) The name of the listener to update.

Example: example_listener
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_listener()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_load_balancer_and_wait_for_state(update_load_balancer_details, load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_load_balancer() and waits for the WorkRequest to enter the given state(s).

Parameters

update_load_balancer_details (oci.load_balancer.models.UpdateLoadBalancerDetails) – (required) The details for updating a load balancer’s configuration.
load_balancer_id (str) –
(required) The OCID of the load balancer to update.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_load_balancer()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_load_balancer_shape_and_wait_for_state(load_balancer_id, update_load_balancer_shape_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_load_balancer_shape() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the load balancer whose shape will be updated.
update_load_balancer_shape_details (oci.load_balancer.models.UpdateLoadBalancerShapeDetails) – (required) The details for updating a load balancer’s shape. This contains the new, desired shape.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_load_balancer_shape()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_network_security_groups_and_wait_for_state(update_network_security_groups_details, load_balancer_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_network_security_groups() and waits for the WorkRequest to enter the given state(s).

Parameters

update_network_security_groups_details (oci.load_balancer.models.UpdateNetworkSecurityGroupsDetails) – (required) The details for updating the NSGs associated with the specified load balancer.
load_balancer_id (str) –
(required) The OCID of the load balancer to update the NSGs for.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_network_security_groups()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_path_route_set_and_wait_for_state(update_path_route_set_details, load_balancer_id, path_route_set_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_path_route_set() and waits for the WorkRequest to enter the given state(s).

Parameters

update_path_route_set_details (oci.load_balancer.models.UpdatePathRouteSetDetails) – (required) The configuration details to update a path route set.
load_balancer_id (str) –
(required) The OCID of the load balancer associated with the path route set to update.
path_route_set_name (str) –
(required) The name of the path route set to update.

Example: example_path_route_set
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_path_route_set()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_routing_policy_and_wait_for_state(update_routing_policy_details, load_balancer_id, routing_policy_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_routing_policy() and waits for the WorkRequest to enter the given state(s).

Parameters

update_routing_policy_details (oci.load_balancer.models.UpdateRoutingPolicyDetails) – (required) The configuration details needed to update a routing policy.
load_balancer_id (str) –
(required) The OCID of the load balancer associated with the routing policy to update.
routing_policy_name (str) –
(required) The name of the routing policy to update.

Example: example_routing_policy_name
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_routing_policy()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_rule_set_and_wait_for_state(load_balancer_id, rule_set_name, update_rule_set_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_rule_set() and waits for the WorkRequest to enter the given state(s).

Parameters

load_balancer_id (str) –
(required) The OCID of the specified load balancer.
rule_set_name (str) –
(required) The name of the rule set to update.

Example: example_rule_set
update_rule_set_details (oci.load_balancer.models.UpdateRuleSetDetails) – (required) The configuration details to update a set of rules.
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_rule_set()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait

update_ssl_cipher_suite_and_wait_for_state(update_ssl_cipher_suite_details, load_balancer_id, name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})¶

Calls update_ssl_cipher_suite() and waits for the WorkRequest to enter the given state(s).

Parameters

update_ssl_cipher_suite_details (oci.load_balancer.models.UpdateSSLCipherSuiteDetails) – (required) The configuration details to update an SSL cipher suite.
load_balancer_id (str) –
(required) The OCID of the associated load balancer.
name (str) –
(required) The name of the SSL cipher suite to update.

example: example_cipher_suite
wait_for_states (list[str]) – An array of states to wait on. These should be valid values for lifecycle_state
operation_kwargs (dict) – A dictionary of keyword arguments to pass to update_ssl_cipher_suite()
waiter_kwargs (dict) – A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait