ruạṛ
a N��f�� � @ s( d dl Z d dlmZ G dd� de�ZdS )� N)�WAIT_RESOURCE_NOT_FOUNDc @ s� e Zd ZdZd3dd�Zg i i fdd�Zg i i fdd�Zg i i fd d �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/d0�Zg i i fd1d2�ZdS )4�%BlockstorageClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.core.BlockstorageClient` 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 Nc K s0 || _ |r|ntjj| j jfi | j j��| _dS )a� Creates a new BlockstorageClientCompositeOperations object :param BlockstorageClient client: The service client which will be wrapped by this object :param oci.work_requests.WorkRequestClient work_request_client: (optional) The work request service client which will be used to wait for work request states. Default is None. N)�client�oci� work_requests�WorkRequestClient�_config�_kwargs�_work_request_client)�selfr �work_request_client�kwargs� r ��/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/oci/core/blockstorage_client_composite_operations.py�__init__ s z.BlockstorageClientCompositeOperations.__init__c s� | j j||fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.core.BlockstorageClient.copy_boot_volume_backup` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str boot_volume_backup_id: (required) The OCID of the boot volume backup. :param oci.core.models.CopyBootVolumeBackupDetails copy_boot_volume_backup_details: (required) Request to create a cross-region copy of given boot volume backup. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.copy_boot_volume_backup` :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>6 � zkBlockstorageClientCompositeOperations.copy_boot_volume_backup_and_wait_for_work_request.<locals>.<listcomp>�opc-work-request-id�evaluate_responsec s t | jd�o t | jd��� � v S �N�status��getattr�datar ��r��lowered_work_request_statesr r �<lambda>= r ziBlockstorageClientCompositeOperations.copy_boot_volume_backup_and_wait_for_work_request.<locals>.<lambda>��partial_results�causeN) r �copy_boot_volume_backupr �waiter� _WORK_REQUEST_TERMINATION_STATES�headers� wait_untilr �get_work_request� Exception� exceptions�CompositeOperationError) r �boot_volume_backup_id� copy_boot_volume_backup_details�work_request_states�operation_kwargs� waiter_kwargs�operation_result�work_request_id� waiter_result�er r! r �1copy_boot_volume_backup_and_wait_for_work_request s � ��zWBlockstorageClientCompositeOperations.copy_boot_volume_backup_and_wait_for_work_requestc s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.core.BlockstorageClient.copy_boot_volume_backup` and waits for the :py:class:`~oci.core.models.BootVolumeBackup` acted upon to enter the given state(s). :param str boot_volume_backup_id: (required) The OCID of the boot volume backup. :param oci.core.models.CopyBootVolumeBackupDetails copy_boot_volume_backup_details: (required) Request to create a cross-region copy of given boot volume backup. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.BootVolumeBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.copy_boot_volume_backup` :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 zdBlockstorageClientCompositeOperations.copy_boot_volume_backup_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S �N�lifecycle_stater r ��lowered_wait_for_statesr r r# d r zbBlockstorageClientCompositeOperations.copy_boot_volume_backup_and_wait_for_state.<locals>.<lambda>�� �a This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"r$ N) r r' r �idr r+ �get_boot_volume_backup� NameError� TypeError�argsr. r/ r- ) r r0 r1 �wait_for_statesr3 r4 r5 r7 �result_to_returnr8 r r< r �*copy_boot_volume_backup_and_wait_for_stateD s. � �� &zPBlockstorageClientCompositeOperations.copy_boot_volume_backup_and_wait_for_statec s� | j j||fi |��}|r |ntjj}dd� |D �� |jd }z0tj| j| j�|�fd� fdd�i|��}|W S t y� } z tj j |g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.core.BlockstorageClient.copy_volume_backup` and waits for the oci.work_requests.models.WorkRequest to enter the given state(s). :param str volume_backup_id: (required) The OCID of the volume backup. :param oci.core.models.CopyVolumeBackupDetails copy_volume_backup_details: (required) Request to create a cross-region copy of given backup. :param list[str] work_request_states: (optional) An array of work requests states to wait on. These should be valid values for :py:attr:`~oci.work_requests.models.WorkRequest.status` Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED] :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.copy_volume_backup` :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 zfBlockstorageClientCompositeOperations.copy_volume_backup_and_wait_for_work_request.<locals>.<listcomp>r r c s t | jd�o t | jd��� � v S r r r r! r r r# � r zdBlockstorageClientCompositeOperations.copy_volume_backup_and_wait_for_work_request.<locals>.<lambda>r$ N) r �copy_volume_backupr r( r) r* r+ r r, r- r. r/ ) r �volume_backup_id�copy_volume_backup_detailsr2 r3 r4 r5 r6 r7 r8 r r! r �,copy_volume_backup_and_wait_for_work_requestr s � ��zRBlockstorageClientCompositeOperations.copy_volume_backup_and_wait_for_work_requestc s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) ai Calls :py:func:`~oci.core.BlockstorageClient.copy_volume_backup` and waits for the :py:class:`~oci.core.models.VolumeBackup` acted upon to enter the given state(s). :param str volume_backup_id: (required) The OCID of the volume backup. :param oci.core.models.CopyVolumeBackupDetails copy_volume_backup_details: (required) Request to create a cross-region copy of given backup. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.copy_volume_backup` :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_BlockstorageClientCompositeOperations.copy_volume_backup_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# � r z]BlockstorageClientCompositeOperations.copy_volume_backup_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r rI r rA r r+ �get_volume_backuprC rD rE r. r/ r- ) r rJ rK rF r3 r4 r5 r7 rG r8 r r< r �%copy_volume_backup_and_wait_for_state� s. � �� &zKBlockstorageClientCompositeOperations.copy_volume_backup_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.core.BlockstorageClient.copy_volume_group_backup` and waits for the :py:class:`~oci.core.models.VolumeGroupBackup` acted upon to enter the given state(s). :param str volume_group_backup_id: (required) The Oracle Cloud ID (OCID) that uniquely identifies the volume group backup. :param oci.core.models.CopyVolumeGroupBackupDetails copy_volume_group_backup_details: (required) Request to create a cross-region copy of given volume group backup. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeGroupBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.copy_volume_group_backup` :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 zeBlockstorageClientCompositeOperations.copy_volume_group_backup_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# � r zcBlockstorageClientCompositeOperations.copy_volume_group_backup_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �copy_volume_group_backupr rA r r+ �get_volume_group_backuprC rD rE r. r/ r- ) r �volume_group_backup_id� copy_volume_group_backup_detailsrF r3 r4 r5 r7 rG r8 r r< r �+copy_volume_group_backup_and_wait_for_state� s. � �� &zQBlockstorageClientCompositeOperations.copy_volume_group_backup_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.core.BlockstorageClient.create_boot_volume` and waits for the :py:class:`~oci.core.models.BootVolume` acted upon to enter the given state(s). :param oci.core.models.CreateBootVolumeDetails create_boot_volume_details: (required) Request to create a new boot volume. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.BootVolume.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.create_boot_volume` :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_BlockstorageClientCompositeOperations.create_boot_volume_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# r z]BlockstorageClientCompositeOperations.create_boot_volume_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �create_boot_volumer rA r r+ �get_boot_volumerC rD rE r. r/ r- ) r �create_boot_volume_detailsrF r3 r4 r5 �boot_volume_idr7 rG r8 r r< r �%create_boot_volume_and_wait_for_state� s. � �� &zKBlockstorageClientCompositeOperations.create_boot_volume_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a. Calls :py:func:`~oci.core.BlockstorageClient.create_boot_volume_backup` and waits for the :py:class:`~oci.core.models.BootVolumeBackup` acted upon to enter the given state(s). :param oci.core.models.CreateBootVolumeBackupDetails create_boot_volume_backup_details: (required) Request to create a new backup of given boot volume. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.BootVolumeBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.create_boot_volume_backup` :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 5 r zfBlockstorageClientCompositeOperations.create_boot_volume_backup_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# < r zdBlockstorageClientCompositeOperations.create_boot_volume_backup_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �create_boot_volume_backupr rA r r+ rB rC rD rE r. r/ r- ) r �!create_boot_volume_backup_detailsrF r3 r4 r5 r0 r7 rG r8 r r< r �,create_boot_volume_backup_and_wait_for_state s. � �� &zRBlockstorageClientCompositeOperations.create_boot_volume_backup_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.core.BlockstorageClient.create_volume` and waits for the :py:class:`~oci.core.models.Volume` acted upon to enter the given state(s). :param oci.core.models.CreateVolumeDetails create_volume_details: (required) Request to create a new volume. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Volume.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.create_volume` :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 zZBlockstorageClientCompositeOperations.create_volume_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# g r zXBlockstorageClientCompositeOperations.create_volume_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r � create_volumer rA r r+ � get_volumerC rD rE r. r/ r- ) r �create_volume_detailsrF r3 r4 r5 � volume_idr7 rG r8 r r< r � create_volume_and_wait_for_stateJ s. � �� &zFBlockstorageClientCompositeOperations.create_volume_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.core.BlockstorageClient.create_volume_backup` and waits for the :py:class:`~oci.core.models.VolumeBackup` acted upon to enter the given state(s). :param oci.core.models.CreateVolumeBackupDetails create_volume_backup_details: (required) Request to create a new backup of given volume. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.create_volume_backup` :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 zaBlockstorageClientCompositeOperations.create_volume_backup_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# � r z_BlockstorageClientCompositeOperations.create_volume_backup_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �create_volume_backupr rA r r+ rM rC rD rE r. r/ r- ) r � create_volume_backup_detailsrF r3 r4 r5 rJ r7 rG r8 r r< r �'create_volume_backup_and_wait_for_stateu s. � �� &zMBlockstorageClientCompositeOperations.create_volume_backup_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.core.BlockstorageClient.create_volume_group` and waits for the :py:class:`~oci.core.models.VolumeGroup` acted upon to enter the given state(s). :param oci.core.models.CreateVolumeGroupDetails create_volume_group_details: (required) Request to create a new volume group. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeGroup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.create_volume_group` :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`BlockstorageClientCompositeOperations.create_volume_group_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# � r z^BlockstorageClientCompositeOperations.create_volume_group_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �create_volume_groupr rA r r+ �get_volume_grouprC rD rE r. r/ r- ) r �create_volume_group_detailsrF r3 r4 r5 �volume_group_idr7 rG r8 r r< r �&create_volume_group_and_wait_for_state� s. � �� &zLBlockstorageClientCompositeOperations.create_volume_group_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a; Calls :py:func:`~oci.core.BlockstorageClient.create_volume_group_backup` and waits for the :py:class:`~oci.core.models.VolumeGroupBackup` acted upon to enter the given state(s). :param oci.core.models.CreateVolumeGroupBackupDetails create_volume_group_backup_details: (required) Request to create a new backup group of given volume group. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeGroupBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.create_volume_group_backup` :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 zgBlockstorageClientCompositeOperations.create_volume_group_backup_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# � r zeBlockstorageClientCompositeOperations.create_volume_group_backup_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �create_volume_group_backupr rA r r+ rP rC rD rE r. r/ r- ) r �"create_volume_group_backup_detailsrF r3 r4 r5 rQ r7 rG r8 r r< r �-create_volume_group_backup_and_wait_for_state� s. � �� &zSBlockstorageClientCompositeOperations.create_volume_group_backup_and_wait_for_statec sD | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.BlockstorageClient.delete_boot_volume` and waits for the :py:class:`~oci.core.models.BootVolume` acted upon to enter the given state(s). :param str boot_volume_id: (required) The OCID of the boot volume. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.BootVolume.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.delete_boot_volume` :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_BlockstorageClientCompositeOperations.delete_boot_volume_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r: r r r< r r r# r z]BlockstorageClientCompositeOperations.delete_boot_volume_and_wait_for_state.<locals>.<lambda>T�r �succeed_on_not_foundr> r@ r$ )r rU �delete_boot_volumer r. � ServiceErrorr r r+ rC rD rE r/ r- ) r rW rF r3 r4 �initial_get_resultr5 r8 r7 rG r r< r �%delete_boot_volume_and_wait_for_state� s< � �� &zKBlockstorageClientCompositeOperations.delete_boot_volume_and_wait_for_statec sD | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.BlockstorageClient.delete_boot_volume_backup` and waits for the :py:class:`~oci.core.models.BootVolumeBackup` acted upon to enter the given state(s). :param str boot_volume_backup_id: (required) The OCID of the boot volume backup. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.BootVolumeBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.delete_boot_volume_backup` :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 Nrl c S s g | ] }|� � �qS r r r r r r r I r zfBlockstorageClientCompositeOperations.delete_boot_volume_backup_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r: r r r< r r r# O r zdBlockstorageClientCompositeOperations.delete_boot_volume_backup_and_wait_for_state.<locals>.<lambda>Trm r> r@ r$ )r rB �delete_boot_volume_backupr r. rp r r r+ rC rD rE r/ r- ) r r0 rF r3 r4 rq r5 r8 r7 rG r r< r �,delete_boot_volume_backup_and_wait_for_state* s< � �� &zRBlockstorageClientCompositeOperations.delete_boot_volume_backup_and_wait_for_statec sD | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.BlockstorageClient.delete_volume` and waits for the :py:class:`~oci.core.models.Volume` acted upon to enter the given state(s). :param str volume_id: (required) The OCID of the volume. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Volume.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.delete_volume` :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 Nrl c S s g | ] }|� � �qS r r r r r r r } r zZBlockstorageClientCompositeOperations.delete_volume_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r: r r r< r r r# � r zXBlockstorageClientCompositeOperations.delete_volume_and_wait_for_state.<locals>.<lambda>Trm r> r@ r$ )r r] � delete_volumer r. rp r r r+ rC rD rE r/ r- ) r r_ rF r3 r4 rq r5 r8 r7 rG r r< r � delete_volume_and_wait_for_state^ s< � �� &zFBlockstorageClientCompositeOperations.delete_volume_and_wait_for_statec sD | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.BlockstorageClient.delete_volume_backup` and waits for the :py:class:`~oci.core.models.VolumeBackup` acted upon to enter the given state(s). :param str volume_backup_id: (required) The OCID of the volume backup. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.delete_volume_backup` :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 Nrl c S s g | ] }|� � �qS r r r r r r r � r zaBlockstorageClientCompositeOperations.delete_volume_backup_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r: r r r< r r r# � r z_BlockstorageClientCompositeOperations.delete_volume_backup_and_wait_for_state.<locals>.<lambda>Trm r> r@ r$ )r rM �delete_volume_backupr r. rp r r r+ rC rD rE r/ r- ) r rJ rF r3 r4 rq r5 r8 r7 rG r r< r �'delete_volume_backup_and_wait_for_state� s< � �� &zMBlockstorageClientCompositeOperations.delete_volume_backup_and_wait_for_statec sD | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a� Calls :py:func:`~oci.core.BlockstorageClient.delete_volume_group` and waits for the :py:class:`~oci.core.models.VolumeGroup` acted upon to enter the given state(s). :param str volume_group_id: (required) The Oracle Cloud ID (OCID) that uniquely identifies the volume group. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeGroup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.delete_volume_group` :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 Nrl c S s g | ] }|� � �qS r r r r r r r � r z`BlockstorageClientCompositeOperations.delete_volume_group_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r: r r r< r r r# � r z^BlockstorageClientCompositeOperations.delete_volume_group_and_wait_for_state.<locals>.<lambda>Trm r> r@ r$ )r re �delete_volume_groupr r. rp r r r+ rC rD rE r/ r- ) r rg rF r3 r4 rq r5 r8 r7 rG r r< r �&delete_volume_group_and_wait_for_state� s< � �� &zLBlockstorageClientCompositeOperations.delete_volume_group_and_wait_for_statec sD | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.core.BlockstorageClient.delete_volume_group_backup` and waits for the :py:class:`~oci.core.models.VolumeGroupBackup` acted upon to enter the given state(s). :param str volume_group_backup_id: (required) The Oracle Cloud ID (OCID) that uniquely identifies the volume group backup. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeGroupBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.delete_volume_group_backup` :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 Nrl c S s g | ] }|� � �qS r r r r r r r r zgBlockstorageClientCompositeOperations.delete_volume_group_backup_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r: r r r< r r r# r zeBlockstorageClientCompositeOperations.delete_volume_group_backup_and_wait_for_state.<locals>.<lambda>Trm r> r@ r$ )r rP �delete_volume_group_backupr r. rp r r r+ rC rD rE r/ r- ) r rQ rF r3 r4 rq r5 r8 r7 rG r r< r �-delete_volume_group_backup_and_wait_for_state� s< � �� &zSBlockstorageClientCompositeOperations.delete_volume_group_backup_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) aM Calls :py:func:`~oci.core.BlockstorageClient.update_boot_volume` and waits for the :py:class:`~oci.core.models.BootVolume` acted upon to enter the given state(s). :param str boot_volume_id: (required) The OCID of the boot volume. :param oci.core.models.UpdateBootVolumeDetails update_boot_volume_details: (required) Update boot volume's display name. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.BootVolume.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.update_boot_volume` :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 G r z_BlockstorageClientCompositeOperations.update_boot_volume_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# N r z]BlockstorageClientCompositeOperations.update_boot_volume_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �update_boot_volumer rA r r+ rU rC rD rE r. r/ r- ) r rW �update_boot_volume_detailsrF r3 r4 r5 r7 rG r8 r r< r �%update_boot_volume_and_wait_for_state. s. � �� &zKBlockstorageClientCompositeOperations.update_boot_volume_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.core.BlockstorageClient.update_boot_volume_backup` and waits for the :py:class:`~oci.core.models.BootVolumeBackup` acted upon to enter the given state(s). :param str boot_volume_backup_id: (required) The OCID of the boot volume backup. :param oci.core.models.UpdateBootVolumeBackupDetails update_boot_volume_backup_details: (required) Update boot volume backup fields :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.BootVolumeBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.update_boot_volume_backup` :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 u r zfBlockstorageClientCompositeOperations.update_boot_volume_backup_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# | r zdBlockstorageClientCompositeOperations.update_boot_volume_backup_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �update_boot_volume_backupr rA r r+ rB rC rD rE r. r/ r- ) r r0 �!update_boot_volume_backup_detailsrF r3 r4 r5 r7 rG r8 r r< r �,update_boot_volume_backup_and_wait_for_state\ s. � �� &zRBlockstorageClientCompositeOperations.update_boot_volume_backup_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) aL Calls :py:func:`~oci.core.BlockstorageClient.update_volume` and waits for the :py:class:`~oci.core.models.Volume` acted upon to enter the given state(s). :param str volume_id: (required) The OCID of the volume. :param oci.core.models.UpdateVolumeDetails update_volume_details: (required) Update volume's display name. Avoid entering confidential information. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Volume.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.update_volume` :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 zZBlockstorageClientCompositeOperations.update_volume_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# � r zXBlockstorageClientCompositeOperations.update_volume_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r � update_volumer rA r r+ r] rC rD rE r. r/ r- ) r r_ �update_volume_detailsrF r3 r4 r5 r7 rG r8 r r< r � update_volume_and_wait_for_state� s. � �� &zFBlockstorageClientCompositeOperations.update_volume_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) aV Calls :py:func:`~oci.core.BlockstorageClient.update_volume_backup` and waits for the :py:class:`~oci.core.models.VolumeBackup` acted upon to enter the given state(s). :param str volume_backup_id: (required) The OCID of the volume backup. :param oci.core.models.UpdateVolumeBackupDetails update_volume_backup_details: (required) Update volume backup fields :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.update_volume_backup` :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 zaBlockstorageClientCompositeOperations.update_volume_backup_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# � r z_BlockstorageClientCompositeOperations.update_volume_backup_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �update_volume_backupr rA r r+ rM rC rD rE r. r/ r- ) r rJ � update_volume_backup_detailsrF r3 r4 r5 r7 rG r8 r r< r �'update_volume_backup_and_wait_for_state� s. � �� &zMBlockstorageClientCompositeOperations.update_volume_backup_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.core.BlockstorageClient.update_volume_group` and waits for the :py:class:`~oci.core.models.VolumeGroup` acted upon to enter the given state(s). :param str volume_group_id: (required) The Oracle Cloud ID (OCID) that uniquely identifies the volume group. :param oci.core.models.UpdateVolumeGroupDetails update_volume_group_details: (required) Update volume group's set of volumes and/or display name :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeGroup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.update_volume_group` :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`BlockstorageClientCompositeOperations.update_volume_group_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# r z^BlockstorageClientCompositeOperations.update_volume_group_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �update_volume_groupr rA r r+ re rC rD rE r. r/ r- ) r rg �update_volume_group_detailsrF r3 r4 r5 r7 rG r8 r r< r �&update_volume_group_and_wait_for_state� s. � �� &zLBlockstorageClientCompositeOperations.update_volume_group_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.core.BlockstorageClient.update_volume_group_backup` and waits for the :py:class:`~oci.core.models.VolumeGroupBackup` acted upon to enter the given state(s). :param str volume_group_backup_id: (required) The Oracle Cloud ID (OCID) that uniquely identifies the volume group backup. :param oci.core.models.UpdateVolumeGroupBackupDetails update_volume_group_backup_details: (required) Update volume group backup fields :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.VolumeGroupBackup.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.BlockstorageClient.update_volume_group_backup` :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 zgBlockstorageClientCompositeOperations.update_volume_group_backup_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r: r r r< r r r# 4 r zeBlockstorageClientCompositeOperations.update_volume_group_backup_and_wait_for_state.<locals>.<lambda>r> r@ r$ N) r �update_volume_group_backupr rA r r+ rP rC rD rE r. r/ r- ) r rQ �"update_volume_group_backup_detailsrF r3 r4 r5 r7 rG r8 r r< r �-update_volume_group_backup_and_wait_for_state s. � �� &zSBlockstorageClientCompositeOperations.update_volume_group_backup_and_wait_for_state)N) �__name__� __module__� __qualname__�__doc__r r9 rH rL rN rS rX r[ r` rc rh rk rr rt rv rx rz r| r r� r� r� r� r� r r r r r s2 &.&..++++++444444.....r )r �oci.utilr �objectr r r r r �<module> s
cải xoăn