ruạṛ
a O��f8E � @ s( d dl Z d dlmZ G dd� de�ZdS )� N)�WAIT_RESOURCE_NOT_FOUNDc @ s( e Zd ZdZdd� Zg i i fdd�Zg i i fdd�Zg i i fdd �Zg i i fd d �Zg i i fd d �Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Zg i i fdd�Zg i i fdd�Zg i i fd d �Zg i i fd d �Zg i i fd d!�Zg i i fd"d#�Zg i i fd$d%�Zg i i fd&d'�Zg i i fd(d)�Zg i i fd*d+�Zg i i fd,d-�Zg i i fd.d/�Zg i i fd0d1�Zg i i fd2d3�Z g i i fd4d5�Z g i i fd6d7�Z g i i fd8d9�Z g i i fd:d;�Z g i i fd<d=�Z!g i i fd>d?�Z"g i i fd@dA�Z#g i i fdBdC�Z$g i i fdDdE�Z%dFS )G�%LoadBalancerClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.load_balancer.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 c K s || _ dS )z� Creates a new LoadBalancerClientCompositeOperations object :param LoadBalancerClient client: The service client which will be wrapped by this object N)�client)�selfr �kwargs� r ��/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/oci/load_balancer/load_balancer_client_composite_operations.py�__init__ s z.LoadBalancerClientCompositeOperations.__init__c s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aB Calls :py:func:`~oci.load_balancer.LoadBalancerClient.change_load_balancer_compartment` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer to move. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.load_balancer.models.ChangeLoadBalancerCompartmentDetails change_load_balancer_compartment_details: (required) The configuration details for moving a load balancer to a different compartment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.change_load_balancer_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r ��lower��.0�wr r r � <listcomp>5 � zmLoadBalancerClientCompositeOperations.change_load_balancer_compartment_and_wait_for_state.<locals>.<listcomp>�opc-work-request-id�evaluate_responsec s t | jd�o t | jd��� � v S �N�lifecycle_state��getattr�datar ��r��lowered_wait_for_statesr r �<lambda>< r zkLoadBalancerClientCompositeOperations.change_load_balancer_compartment_and_wait_for_state.<locals>.<lambda>��partial_results�causeN) r � change_load_balancer_compartment�headers�oci� wait_until�get_work_request� Exception� exceptions�CompositeOperationError) r �load_balancer_id�(change_load_balancer_compartment_details�wait_for_states�operation_kwargs� waiter_kwargs�operation_result�wait_for_resource_id� waiter_result�result_to_return�er r r �3change_load_balancer_compartment_and_wait_for_state s$ � ��zYLoadBalancerClientCompositeOperations.change_load_balancer_compartment_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_backend` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.CreateBackendDetails create_backend_details: (required) The details to add a backend server to a backend set. :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the backend set and servers. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str backend_set_name: (required) The name of the backend set to add the backend server to. Example: `example_backend_set` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_backend` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r e r z[LoadBalancerClientCompositeOperations.create_backend_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r l r zYLoadBalancerClientCompositeOperations.create_backend_and_wait_for_state.<locals>.<lambda>r N) r �create_backendr! r" r# r$ r% r& r' ) r �create_backend_detailsr( �backend_set_namer* r+ r, r- r. r/ r0 r1 r r r �!create_backend_and_wait_for_stateE s$ � ��zGLoadBalancerClientCompositeOperations.create_backend_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_backend_set` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.CreateBackendSetDetails create_backend_set_details: (required) The details for adding a backend set. :param str load_balancer_id: (required) The `OCID`__ of the load balancer on which to add a backend set. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_backend_set` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r z_LoadBalancerClientCompositeOperations.create_backend_set_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]LoadBalancerClientCompositeOperations.create_backend_set_and_wait_for_state.<locals>.<lambda>r N) r �create_backend_setr! r" r# r$ r% r& r' ) r �create_backend_set_detailsr( r* r+ r, r- r. r/ r0 r1 r r r �%create_backend_set_and_wait_for_stateu s$ � ��zKLoadBalancerClientCompositeOperations.create_backend_set_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_certificate` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.CreateCertificateDetails create_certificate_details: (required) The details of the certificate bundle to add. :param str load_balancer_id: (required) The `OCID`__ of the load balancer on which to add the certificate bundle. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_certificate` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r z_LoadBalancerClientCompositeOperations.create_certificate_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]LoadBalancerClientCompositeOperations.create_certificate_and_wait_for_state.<locals>.<lambda>r N) r �create_certificater! r" r# r$ r% r& r' ) r �create_certificate_detailsr( r* r+ r, r- r. r/ r0 r1 r r r �%create_certificate_and_wait_for_state� s$ � ��zKLoadBalancerClientCompositeOperations.create_certificate_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_hostname` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.CreateHostnameDetails create_hostname_details: (required) The details of the hostname resource to add to the specified load balancer. :param str load_balancer_id: (required) The `OCID`__ of the load balancer to add the hostname to. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_hostname` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r z\LoadBalancerClientCompositeOperations.create_hostname_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZLoadBalancerClientCompositeOperations.create_hostname_and_wait_for_state.<locals>.<lambda>r N) r �create_hostnamer! r" r# r$ r% r& r' ) r �create_hostname_detailsr( r* r+ r, r- r. r/ r0 r1 r r r �"create_hostname_and_wait_for_state� s$ � ��zHLoadBalancerClientCompositeOperations.create_hostname_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_listener` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.CreateListenerDetails create_listener_details: (required) Details to add a listener. :param str load_balancer_id: (required) The `OCID`__ of the load balancer on which to add a listener. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_listener` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r r z\LoadBalancerClientCompositeOperations.create_listener_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zZLoadBalancerClientCompositeOperations.create_listener_and_wait_for_state.<locals>.<lambda>r N) r �create_listenerr! r" r# r$ r% r& r' ) r �create_listener_detailsr( r* r+ r, r- r. r/ r0 r1 r r r �"create_listener_and_wait_for_state� s$ � ��zHLoadBalancerClientCompositeOperations.create_listener_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jd }z@tj| j | j �|�fd� fdd�i|��}| j �|jj�}|W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) a6 Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_load_balancer` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.CreateLoadBalancerDetails create_load_balancer_details: (required) The configuration details for creating a load balancer. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_load_balancer` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r 7 r zaLoadBalancerClientCompositeOperations.create_load_balancer_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r > r z_LoadBalancerClientCompositeOperations.create_load_balancer_and_wait_for_state.<locals>.<lambda>r N) r �create_load_balancerr! r" r# r$ �get_load_balancerr r( r% r& r' ) r � create_load_balancer_detailsr* r+ r, r- r. r/ r0 r1 r r r �'create_load_balancer_and_wait_for_state! s$ � ��zMLoadBalancerClientCompositeOperations.create_load_balancer_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_path_route_set` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.CreatePathRouteSetDetails create_path_route_set_details: (required) The details of the path route set to add. :param str load_balancer_id: (required) The `OCID`__ of the load balancer to add the path route set to. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_path_route_set` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r b r zbLoadBalancerClientCompositeOperations.create_path_route_set_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r i r z`LoadBalancerClientCompositeOperations.create_path_route_set_and_wait_for_state.<locals>.<lambda>r N) r �create_path_route_setr! r" r# r$ r% r& r' ) r � create_path_route_set_detailsr( r* r+ r, r- r. r/ r0 r1 r r r �(create_path_route_set_and_wait_for_stateG s$ � ��zNLoadBalancerClientCompositeOperations.create_path_route_set_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_routing_policy` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.CreateRoutingPolicyDetails create_routing_policy_details: (required) The details of the routing policy rules to add. :param str load_balancer_id: (required) The `OCID`__ of the load balancer to add the routing policy rule list to. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_routing_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r zbLoadBalancerClientCompositeOperations.create_routing_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z`LoadBalancerClientCompositeOperations.create_routing_policy_and_wait_for_state.<locals>.<lambda>r N) r �create_routing_policyr! r" r# r$ r% r& r' ) r � create_routing_policy_detailsr( r* r+ r, r- r. r/ r0 r1 r r r �(create_routing_policy_and_wait_for_stater s$ � ��zNLoadBalancerClientCompositeOperations.create_routing_policy_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_rule_set` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the specified load balancer. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param oci.load_balancer.models.CreateRuleSetDetails create_rule_set_details: (required) The configuration details for the rule set to create. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_rule_set` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r z\LoadBalancerClientCompositeOperations.create_rule_set_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZLoadBalancerClientCompositeOperations.create_rule_set_and_wait_for_state.<locals>.<lambda>r N) r �create_rule_setr! r" r# r$ r% r& r' ) r r( �create_rule_set_detailsr* r+ r, r- r. r/ r0 r1 r r r �"create_rule_set_and_wait_for_state� s$ � ��zHLoadBalancerClientCompositeOperations.create_rule_set_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.create_ssl_cipher_suite` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.CreateSSLCipherSuiteDetails create_ssl_cipher_suite_details: (required) The details of the SSL cipher suite to add. :param str load_balancer_id: (required) The `OCID`__ of the associated load balancer. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.create_ssl_cipher_suite` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r zdLoadBalancerClientCompositeOperations.create_ssl_cipher_suite_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbLoadBalancerClientCompositeOperations.create_ssl_cipher_suite_and_wait_for_state.<locals>.<lambda>r N) r �create_ssl_cipher_suiter! r" r# r$ r% r& r' ) r � create_ssl_cipher_suite_detailsr( r* r+ r, r- r. r/ r0 r1 r r r �*create_ssl_cipher_suite_and_wait_for_state� s$ � ��zPLoadBalancerClientCompositeOperations.create_ssl_cipher_suite_and_wait_for_statec s� d}z | j j|||fi |��}W nF tjjyf } z*|jdkrNtW Y d}~S |�W Y d}~n d}~0 0 |sp|S dd� |D �� |jd } z4tj| j | j � | �fd� fdd�i|��} | } | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_backend` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the backend set and server. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str backend_set_name: (required) The name of the backend set associated with the backend server. Example: `example_backend_set` :param str backend_name: (required) The IP address and port of the backend server to remove. Example: `10.0.0.3:8080` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_backend` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 N� c S s g | ] }|� � �qS r r r r r r r r z[LoadBalancerClientCompositeOperations.delete_backend_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r $ r zYLoadBalancerClientCompositeOperations.delete_backend_and_wait_for_state.<locals>.<lambda>r ) r �delete_backendr" r& � ServiceError�statusr r! r# r$ r% r' ) r r( r5 � backend_namer* r+ r, r- r1 r. r/ r0 r r r �!delete_backend_and_wait_for_state� s0 � ��zGLoadBalancerClientCompositeOperations.delete_backend_and_wait_for_statec s� d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_backend_set` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the backend set. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str backend_set_name: (required) The name of the backend set to delete. Example: `example_backend_set` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_backend_set` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 NrS c S s g | ] }|� � �qS r r r r r r r R r z_LoadBalancerClientCompositeOperations.delete_backend_set_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r Y r z]LoadBalancerClientCompositeOperations.delete_backend_set_and_wait_for_state.<locals>.<lambda>r ) r �delete_backend_setr" r& rU rV r r! r# r$ r% r' ) r r( r5 r* r+ r, r- r1 r. r/ r0 r r r �%delete_backend_set_and_wait_for_state- s0 � ��zKLoadBalancerClientCompositeOperations.delete_backend_set_and_wait_for_statec s� d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_certificate` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the certificate bundle to be deleted. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str certificate_name: (required) The name of the certificate bundle to delete. Example: `example_certificate_bundle` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_certificate` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 NrS c S s g | ] }|� � �qS r r r r r r r � r z_LoadBalancerClientCompositeOperations.delete_certificate_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z]LoadBalancerClientCompositeOperations.delete_certificate_and_wait_for_state.<locals>.<lambda>r ) r �delete_certificater" r& rU rV r r! r# r$ r% r' ) r r( �certificate_namer* r+ r, r- r1 r. r/ r0 r r r �%delete_certificate_and_wait_for_stateb s0 � ��zKLoadBalancerClientCompositeOperations.delete_certificate_and_wait_for_statec s� d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_hostname` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the hostname to delete. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str name: (required) The name of the hostname resource to delete. Example: `example_hostname_001` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_hostname` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 NrS c S s g | ] }|� � �qS r r r r r r r � r z\LoadBalancerClientCompositeOperations.delete_hostname_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZLoadBalancerClientCompositeOperations.delete_hostname_and_wait_for_state.<locals>.<lambda>r ) r �delete_hostnamer" r& rU rV r r! r# r$ r% r' � r r( �namer* r+ r, r- r1 r. r/ r0 r r r �"delete_hostname_and_wait_for_state� s0 � ��zHLoadBalancerClientCompositeOperations.delete_hostname_and_wait_for_statec s� d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_listener` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the listener to delete. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str listener_name: (required) The name of the listener to delete. Example: `example_listener` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_listener` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 NrS c S s g | ] }|� � �qS r r r r r r r � r z\LoadBalancerClientCompositeOperations.delete_listener_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZLoadBalancerClientCompositeOperations.delete_listener_and_wait_for_state.<locals>.<lambda>r ) r �delete_listenerr" r& rU rV r r! r# r$ r% r' ) r r( � listener_namer* r+ r, r- r1 r. r/ r0 r r r �"delete_listener_and_wait_for_state� s0 � ��zHLoadBalancerClientCompositeOperations.delete_listener_and_wait_for_statec s� d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) aG Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_load_balancer` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer to delete. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_load_balancer` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 NrS c S s g | ] }|� � �qS r r r r r r r " r zaLoadBalancerClientCompositeOperations.delete_load_balancer_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ) r z_LoadBalancerClientCompositeOperations.delete_load_balancer_and_wait_for_state.<locals>.<lambda>r ) r �delete_load_balancerr" r& rU rV r r! r# r$ r% r' ) r r( r* r+ r, r- r1 r. r/ r0 r r r �'delete_load_balancer_and_wait_for_state s0 � ��zMLoadBalancerClientCompositeOperations.delete_load_balancer_and_wait_for_statec s� d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_path_route_set` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the path route set to delete. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str path_route_set_name: (required) The name of the path route set to delete. Example: `example_path_route_set` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_path_route_set` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 NrS c S s g | ] }|� � �qS r r r r r r r W r zbLoadBalancerClientCompositeOperations.delete_path_route_set_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r ^ r z`LoadBalancerClientCompositeOperations.delete_path_route_set_and_wait_for_state.<locals>.<lambda>r ) r �delete_path_route_setr" r& rU rV r r! r# r$ r% r' ) r r( �path_route_set_namer* r+ r, r- r1 r. r/ r0 r r r �(delete_path_route_set_and_wait_for_state2 s0 � ��zNLoadBalancerClientCompositeOperations.delete_path_route_set_and_wait_for_statec s� d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_routing_policy` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the routing policy to delete. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str routing_policy_name: (required) The name of the routing policy to delete. Example: `example_routing_policy` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_routing_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 NrS c S s g | ] }|� � �qS r r r r r r r � r zbLoadBalancerClientCompositeOperations.delete_routing_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z`LoadBalancerClientCompositeOperations.delete_routing_policy_and_wait_for_state.<locals>.<lambda>r ) r �delete_routing_policyr" r& rU rV r r! r# r$ r% r' ) r r( �routing_policy_namer* r+ r, r- r1 r. r/ r0 r r r �(delete_routing_policy_and_wait_for_stateg s0 � ��zNLoadBalancerClientCompositeOperations.delete_routing_policy_and_wait_for_statec s� d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_rule_set` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the specified load balancer. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str rule_set_name: (required) The name of the rule set to delete. Example: `example_rule_set` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_rule_set` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 NrS c S s g | ] }|� � �qS r r r r r r r � r z\LoadBalancerClientCompositeOperations.delete_rule_set_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZLoadBalancerClientCompositeOperations.delete_rule_set_and_wait_for_state.<locals>.<lambda>r ) r �delete_rule_setr" r& rU rV r r! r# r$ r% r' ) r r( � rule_set_namer* r+ r, r- r1 r. r/ r0 r r r �"delete_rule_set_and_wait_for_state� s0 � ��zHLoadBalancerClientCompositeOperations.delete_rule_set_and_wait_for_statec s� d}z| j j||fi |��}W nF tjjyd } z*|jdkrLtW Y d}~S |�W Y d}~n d}~0 0 |sn|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��} | } | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.delete_ssl_cipher_suite` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the associated load balancer. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str name: (required) The name of the SSL cipher suite to delete. example: `example_cipher_suite` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.delete_ssl_cipher_suite` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 NrS c S s g | ] }|� � �qS r r r r r r r � r zdLoadBalancerClientCompositeOperations.delete_ssl_cipher_suite_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zbLoadBalancerClientCompositeOperations.delete_ssl_cipher_suite_and_wait_for_state.<locals>.<lambda>r ) r �delete_ssl_cipher_suiter" r& rU rV r r! r# r$ r% r' r_ r r r �*delete_ssl_cipher_suite_and_wait_for_state� s0 � ��zPLoadBalancerClientCompositeOperations.delete_ssl_cipher_suite_and_wait_for_statec s� | j j||||fi |��}|s"|S dd� |D �� |jd } z4tj| j | j �| �fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a1 Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_backend` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdateBackendDetails update_backend_details: (required) Details for updating a backend server. :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the backend set and server. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str backend_set_name: (required) The name of the backend set associated with the backend server. Example: `example_backend_set` :param str backend_name: (required) The IP address and port of the backend server to update. Example: `10.0.0.3:8080` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_backend` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r + r z[LoadBalancerClientCompositeOperations.update_backend_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 2 r zYLoadBalancerClientCompositeOperations.update_backend_and_wait_for_state.<locals>.<lambda>r N) r �update_backendr! r" r# r$ r% r& r' ) r �update_backend_detailsr( r5 rW r* r+ r, r- r. r/ r0 r1 r r r �!update_backend_and_wait_for_state s$ ! � ��zGLoadBalancerClientCompositeOperations.update_backend_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_backend_set` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdateBackendSetDetails update_backend_set_details: (required) The details to update a backend set. :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the backend set. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str backend_set_name: (required) The name of the backend set to update. Example: `example_backend_set` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_backend_set` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r [ r z_LoadBalancerClientCompositeOperations.update_backend_set_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r b r z]LoadBalancerClientCompositeOperations.update_backend_set_and_wait_for_state.<locals>.<lambda>r N) r �update_backend_setr! r" r# r$ r% r& r' ) r �update_backend_set_detailsr( r5 r* r+ r, r- r. r/ r0 r1 r r r �%update_backend_set_and_wait_for_state; s$ � ��zKLoadBalancerClientCompositeOperations.update_backend_set_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_health_checker` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdateHealthCheckerDetails health_checker: (required) The health check policy configuration details. :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the health check policy to be updated. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str backend_set_name: (required) The name of the backend set associated with the health check policy to be retrieved. Example: `example_backend_set` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_health_checker` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r zbLoadBalancerClientCompositeOperations.update_health_checker_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z`LoadBalancerClientCompositeOperations.update_health_checker_and_wait_for_state.<locals>.<lambda>r N) r �update_health_checkerr! r" r# r$ r% r& r' ) r �health_checkerr( r5 r* r+ r, r- r. r/ r0 r1 r r r �(update_health_checker_and_wait_for_statek s$ � ��zNLoadBalancerClientCompositeOperations.update_health_checker_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_hostname` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdateHostnameDetails update_hostname_details: (required) The configuration details to update a virtual hostname. :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the virtual hostname to update. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str name: (required) The name of the hostname resource to update. Example: `example_hostname_001` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_hostname` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r z\LoadBalancerClientCompositeOperations.update_hostname_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZLoadBalancerClientCompositeOperations.update_hostname_and_wait_for_state.<locals>.<lambda>r N) r �update_hostnamer! r" r# r$ r% r& r' ) r �update_hostname_detailsr( r` r* r+ r, r- r. r/ r0 r1 r r r �"update_hostname_and_wait_for_state� s$ � ��zHLoadBalancerClientCompositeOperations.update_hostname_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) an Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_listener` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdateListenerDetails update_listener_details: (required) Details to update a listener. :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the listener to update. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str listener_name: (required) The name of the listener to update. Example: `example_listener` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_listener` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r z\LoadBalancerClientCompositeOperations.update_listener_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r zZLoadBalancerClientCompositeOperations.update_listener_and_wait_for_state.<locals>.<lambda>r N) r �update_listenerr! r" r# r$ r% r& r' ) r �update_listener_detailsr( rc r* r+ r, r- r. r/ r0 r1 r r r �"update_listener_and_wait_for_state� s$ � ��zHLoadBalancerClientCompositeOperations.update_listener_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z@tj| j | j �|�fd� fdd�i|��}| j �|jj�} | W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_load_balancer` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdateLoadBalancerDetails update_load_balancer_details: (required) The details for updating a load balancer's configuration. :param str load_balancer_id: (required) The `OCID`__ of the load balancer to update. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_load_balancer` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r r zaLoadBalancerClientCompositeOperations.update_load_balancer_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r z_LoadBalancerClientCompositeOperations.update_load_balancer_and_wait_for_state.<locals>.<lambda>r N) r �update_load_balancerr! r" r# r$ rD r r( r% r& r' ) r � update_load_balancer_detailsr( r* r+ r, r- r. r/ r0 r1 r r r �'update_load_balancer_and_wait_for_state� s$ � ��zMLoadBalancerClientCompositeOperations.update_load_balancer_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aE Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_load_balancer_shape` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the load balancer whose shape will be updated. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.load_balancer.models.UpdateLoadBalancerShapeDetails update_load_balancer_shape_details: (required) The details for updating a load balancer's shape. This contains the new, desired shape. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_load_balancer_shape` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r B r zgLoadBalancerClientCompositeOperations.update_load_balancer_shape_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r I r zeLoadBalancerClientCompositeOperations.update_load_balancer_shape_and_wait_for_state.<locals>.<lambda>r N) r �update_load_balancer_shaper! r" r# r$ r% r& r' ) r r( �"update_load_balancer_shape_detailsr* r+ r, r- r. r/ r0 r1 r r r �-update_load_balancer_shape_and_wait_for_state' s$ � ��zSLoadBalancerClientCompositeOperations.update_load_balancer_shape_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aB Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_network_security_groups` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdateNetworkSecurityGroupsDetails update_network_security_groups_details: (required) The details for updating the NSGs associated with the specified load balancer. :param str load_balancer_id: (required) The `OCID`__ of the load balancer to update the NSGs for. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_network_security_groups` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r m r zkLoadBalancerClientCompositeOperations.update_network_security_groups_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r t r ziLoadBalancerClientCompositeOperations.update_network_security_groups_and_wait_for_state.<locals>.<lambda>r N) r � update_network_security_groupsr! r" r# r$ r% r& r' ) r �&update_network_security_groups_detailsr( r* r+ r, r- r. r/ r0 r1 r r r �1update_network_security_groups_and_wait_for_stateR s$ � ��zWLoadBalancerClientCompositeOperations.update_network_security_groups_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_path_route_set` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdatePathRouteSetDetails update_path_route_set_details: (required) The configuration details to update a path route set. :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the path route set to update. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str path_route_set_name: (required) The name of the path route set to update. Example: `example_path_route_set` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_path_route_set` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r zbLoadBalancerClientCompositeOperations.update_path_route_set_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z`LoadBalancerClientCompositeOperations.update_path_route_set_and_wait_for_state.<locals>.<lambda>r N) r �update_path_route_setr! r" r# r$ r% r& r' ) r � update_path_route_set_detailsr( rh r* r+ r, r- r. r/ r0 r1 r r r �(update_path_route_set_and_wait_for_state} s$ � ��zNLoadBalancerClientCompositeOperations.update_path_route_set_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_routing_policy` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdateRoutingPolicyDetails update_routing_policy_details: (required) The configuration details needed to update a routing policy. :param str load_balancer_id: (required) The `OCID`__ of the load balancer associated with the routing policy to update. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str routing_policy_name: (required) The name of the routing policy to update. Example: `example_routing_policy_name` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_routing_policy` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r zbLoadBalancerClientCompositeOperations.update_routing_policy_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r � r z`LoadBalancerClientCompositeOperations.update_routing_policy_and_wait_for_state.<locals>.<lambda>r N) r �update_routing_policyr! r" r# r$ r% r& r' ) r � update_routing_policy_detailsr( rk r* r+ r, r- r. r/ r0 r1 r r r �(update_routing_policy_and_wait_for_state� s$ � ��zNLoadBalancerClientCompositeOperations.update_routing_policy_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) af Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_rule_set` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param str load_balancer_id: (required) The `OCID`__ of the specified load balancer. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str rule_set_name: (required) The name of the rule set to update. Example: `example_rule_set` :param oci.load_balancer.models.UpdateRuleSetDetails update_rule_set_details: (required) The configuration details to update a set of rules. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_rule_set` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r � r z\LoadBalancerClientCompositeOperations.update_rule_set_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r r zZLoadBalancerClientCompositeOperations.update_rule_set_and_wait_for_state.<locals>.<lambda>r N) r �update_rule_setr! r" r# r$ r% r& r' ) r r( rn �update_rule_set_detailsr* r+ r, r- r. r/ r0 r1 r r r �"update_rule_set_and_wait_for_state� s$ � ��zHLoadBalancerClientCompositeOperations.update_rule_set_and_wait_for_statec s� | j j|||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��} | } | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.load_balancer.LoadBalancerClient.update_ssl_cipher_suite` and waits for the :py:class:`~oci.load_balancer.models.WorkRequest` to enter the given state(s). :param oci.load_balancer.models.UpdateSSLCipherSuiteDetails update_ssl_cipher_suite_details: (required) The configuration details to update an SSL cipher suite. :param str load_balancer_id: (required) The `OCID`__ of the associated load balancer. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param str name: (required) The name of the SSL cipher suite to update. example: `example_cipher_suite` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.load_balancer.models.WorkRequest.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.load_balancer.LoadBalancerClient.update_ssl_cipher_suite` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 c S s g | ] }|� � �qS r r r r r r r - r zdLoadBalancerClientCompositeOperations.update_ssl_cipher_suite_and_wait_for_state.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r r r r 4 r zbLoadBalancerClientCompositeOperations.update_ssl_cipher_suite_and_wait_for_state.<locals>.<lambda>r N) r �update_ssl_cipher_suiter! r" r# r$ r% r& r' ) r � update_ssl_cipher_suite_detailsr( r` r* r+ r, r- r. r/ r0 r1 r r r �*update_ssl_cipher_suite_and_wait_for_state s$ � ��zPLoadBalancerClientCompositeOperations.update_ssl_cipher_suite_and_wait_for_stateN)&�__name__� __module__� __qualname__�__doc__r r2 r6 r9 r< r? rB rF rI rL rO rR rX rZ r] ra rd rf ri rl ro rq rt rw rz r} r� r� r� r� r� r� r� r� r r r r r sF +0++++&++++:56550555550010+++000r )r" �oci.utilr �objectr r r r r �<module> s
cải xoăn