Releasing version 2.43.2

Author: bhagwatvyas

CHANGELOG.rst

@@ -3,6 +3,20 @@ Change Log
 All notable changes to this project will be documented in this file.
 
 The format is based on `Keep a Changelog <http://keepachangelog.com/>`_.
+====================
+2.43.2 - 2021-08-03
+====================
+
+Added
+-----
+* Support for manually copying volume group backups across regions in the Block Volume service
+* Support for work requests for the copy volume backup and copy boot volume backup operations in the Block Volume service
+* Support for specifying external Hive metastores during application creation in the Data Flow service
+* Support for changing the compartment of a backup in the MySQL Database service
+* Support for model catalog features including provenance, metadata, schemas, and artifact introspection in the Data Science service
+* Support for Exadata system network bonding in the Database service
+* Support for creating autonomous databases with early patching enabled in the Database service
+
 ====================
 2.43.1 - 2021-07-27
 ====================

docs/api/core.rst

@@ -130,6 +130,7 @@ Core Services
     oci.core.models.ConsoleHistory
     oci.core.models.CopyBootVolumeBackupDetails
     oci.core.models.CopyVolumeBackupDetails
+    oci.core.models.CopyVolumeGroupBackupDetails
     oci.core.models.Cpe
     oci.core.models.CpeDeviceConfigAnswer
     oci.core.models.CpeDeviceConfigQuestion

docs/api/core/models/oci.core.models.CopyVolumeGroupBackupDetails.rst

@@ -0,0 +1,11 @@
+CopyVolumeGroupBackupDetails
+============================
+
+.. currentmodule:: oci.core.models
+
+.. autoclass:: CopyVolumeGroupBackupDetails
+    :show-inheritance:
+    :special-members: __init__
+    :members:
+    :undoc-members:
+    :inherited-members:

docs/api/data_science.rst

@@ -31,6 +31,7 @@ Data Science
     oci.data_science.models.FixedSizeScalingPolicy
     oci.data_science.models.InstanceConfiguration
     oci.data_science.models.LogDetails
+    oci.data_science.models.Metadata
     oci.data_science.models.Model
     oci.data_science.models.ModelConfigurationDetails
     oci.data_science.models.ModelDeployment

docs/api/data_science/models/oci.data_science.models.Metadata.rst

@@ -0,0 +1,11 @@
+Metadata
+========
+
+.. currentmodule:: oci.data_science.models
+
+.. autoclass:: Metadata
+    :show-inheritance:
+    :special-members: __init__
+    :members:
+    :undoc-members:
+    :inherited-members:

docs/api/mysql.rst

@@ -38,6 +38,7 @@ Mysql
     oci.mysql.models.BackupPolicy
     oci.mysql.models.BackupSummary
     oci.mysql.models.CaCertificate
+    oci.mysql.models.ChangeBackupCompartmentDetails
     oci.mysql.models.Channel
     oci.mysql.models.ChannelSource
     oci.mysql.models.ChannelSourceMysql

docs/api/mysql/models/oci.mysql.models.ChangeBackupCompartmentDetails.rst

@@ -0,0 +1,11 @@
+ChangeBackupCompartmentDetails
+==============================
+
+.. currentmodule:: oci.mysql.models
+
+.. autoclass:: ChangeBackupCompartmentDetails
+    :show-inheritance:
+    :special-members: __init__
+    :members:
+    :undoc-members:
+    :inherited-members:

src/oci/core/blockstorage_client.py

@@ -780,6 +780,101 @@ def copy_volume_backup(self, volume_backup_id, copy_volume_backup_details, **kwa
                 body=copy_volume_backup_details,
                 response_type="VolumeBackup")
 
+    def copy_volume_group_backup(self, volume_group_backup_id, copy_volume_group_backup_details, **kwargs):
+        """
+        Creates a volume group backup copy in specified region. For general information about volume group backups,
+        see `Overview of Block Volume Service Backups`__
+
+        __ https://docs.cloud.oracle.com/Content/Block/Concepts/blockvolumebackups.htm
+
+
+        :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 str opc_retry_token: (optional)
+            A token that uniquely identifies a request so it can be retried in case of a timeout or
+            server error without risk of executing that same action again. Retry tokens expire after 24
+            hours, but can be invalidated before then due to conflicting operations (for example, if a resource
+            has been deleted and purged from the system, then a retry of the original creation request
+            may be rejected).
+
+        :param str opc_request_id: (optional)
+            Unique identifier for the request.
+            If you need to contact Oracle about a particular request, please provide the request ID.
+
+        :param obj retry_strategy: (optional)
+            A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
+
+            This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
+            is also available. The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
+
+            To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
+
+        :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.core.models.VolumeGroupBackup`
+        :rtype: :class:`~oci.response.Response`
+
+        :example:
+        Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/core/copy_volume_group_backup.py.html>`__ to see an example of how to use copy_volume_group_backup API.
+        """
+        resource_path = "/volumeGroupBackups/{volumeGroupBackupId}/actions/copy"
+        method = "POST"
+
+        # Don't accept unknown kwargs
+        expected_kwargs = [
+            "retry_strategy",
+            "opc_retry_token",
+            "opc_request_id"
+        ]
+        extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
+        if extra_kwargs:
+            raise ValueError(
+                "copy_volume_group_backup got unknown kwargs: {!r}".format(extra_kwargs))
+
+        path_params = {
+            "volumeGroupBackupId": volume_group_backup_id
+        }
+
+        path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
+
+        for (k, v) in six.iteritems(path_params):
+            if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
+                raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
+
+        header_params = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "opc-retry-token": kwargs.get("opc_retry_token", missing),
+            "opc-request-id": kwargs.get("opc_request_id", missing)
+        }
+        header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
+
+        retry_strategy = self.retry_strategy
+        if kwargs.get('retry_strategy'):
+            retry_strategy = kwargs.get('retry_strategy')
+
+        if retry_strategy:
+            if not isinstance(retry_strategy, retry.NoneRetryStrategy):
+                self.base_client.add_opc_retry_token_if_needed(header_params)
+            return retry_strategy.make_retrying_call(
+                self.base_client.call_api,
+                resource_path=resource_path,
+                method=method,
+                path_params=path_params,
+                header_params=header_params,
+                body=copy_volume_group_backup_details,
+                response_type="VolumeGroupBackup")
+        else:
+            return self.base_client.call_api(
+                resource_path=resource_path,
+                method=method,
+                path_params=path_params,
+                header_params=header_params,
+                body=copy_volume_group_backup_details,
+                response_type="VolumeGroupBackup")
+
     def create_boot_volume(self, create_boot_volume_details, **kwargs):
         """
         Creates a new boot volume in the specified compartment from an existing boot volume or a boot volume backup.

src/oci/core/blockstorage_client_composite_operations.py

@@ -27,6 +27,44 @@ def __init__(self, client, work_request_client=None, **kwargs):
         self.client = client
         self._work_request_client = work_request_client if work_request_client else oci.work_requests.WorkRequestClient(self.client._config, **self.client._kwargs)
 
+    def copy_boot_volume_backup_and_wait_for_work_request(self, boot_volume_backup_id, copy_boot_volume_backup_details, work_request_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        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
+        """
+        operation_result = self.client.copy_boot_volume_backup(boot_volume_backup_id, copy_boot_volume_backup_details, **operation_kwargs)
+        work_request_states = work_request_states if work_request_states else oci.waiter._WORK_REQUEST_TERMINATION_STATES
+        lowered_work_request_states = [w.lower() for w in work_request_states]
+        work_request_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self._work_request_client,
+                self._work_request_client.get_work_request(work_request_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_work_request_states,
+                **waiter_kwargs
+            )
+            return waiter_result
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
     def copy_boot_volume_backup_and_wait_for_state(self, boot_volume_backup_id, copy_boot_volume_backup_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.core.BlockstorageClient.copy_boot_volume_backup` and waits for the :py:class:`~oci.core.models.BootVolumeBackup` acted upon
@@ -68,6 +106,44 @@ def copy_boot_volume_backup_and_wait_for_state(self, boot_volume_backup_id, copy
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def copy_volume_backup_and_wait_for_work_request(self, volume_backup_id, copy_volume_backup_details, work_request_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        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
+        """
+        operation_result = self.client.copy_volume_backup(volume_backup_id, copy_volume_backup_details, **operation_kwargs)
+        work_request_states = work_request_states if work_request_states else oci.waiter._WORK_REQUEST_TERMINATION_STATES
+        lowered_work_request_states = [w.lower() for w in work_request_states]
+        work_request_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self._work_request_client,
+                self._work_request_client.get_work_request(work_request_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_work_request_states,
+                **waiter_kwargs
+            )
+            return waiter_result
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
     def copy_volume_backup_and_wait_for_state(self, volume_backup_id, copy_volume_backup_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.core.BlockstorageClient.copy_volume_backup` and waits for the :py:class:`~oci.core.models.VolumeBackup` acted upon
@@ -109,6 +185,47 @@ def copy_volume_backup_and_wait_for_state(self, volume_backup_id, copy_volume_ba
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def copy_volume_group_backup_and_wait_for_state(self, volume_group_backup_id, copy_volume_group_backup_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        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
+        """
+        operation_result = self.client.copy_volume_group_backup(volume_group_backup_id, copy_volume_group_backup_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        wait_for_resource_id = operation_result.data.id
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_volume_group_backup(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
     def create_boot_volume_and_wait_for_state(self, create_boot_volume_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.core.BlockstorageClient.create_boot_volume` and waits for the :py:class:`~oci.core.models.BootVolume` acted upon

src/oci/core/models/__init__.py

@@ -110,6 +110,7 @@
 from .console_history import ConsoleHistory
 from .copy_boot_volume_backup_details import CopyBootVolumeBackupDetails
 from .copy_volume_backup_details import CopyVolumeBackupDetails
+from .copy_volume_group_backup_details import CopyVolumeGroupBackupDetails
 from .cpe import Cpe
 from .cpe_device_config_answer import CpeDeviceConfigAnswer
 from .cpe_device_config_question import CpeDeviceConfigQuestion
@@ -546,6 +547,7 @@
     "ConsoleHistory": ConsoleHistory,
     "CopyBootVolumeBackupDetails": CopyBootVolumeBackupDetails,
     "CopyVolumeBackupDetails": CopyVolumeBackupDetails,
+    "CopyVolumeGroupBackupDetails": CopyVolumeGroupBackupDetails,
     "Cpe": Cpe,
     "CpeDeviceConfigAnswer": CpeDeviceConfigAnswer,
     "CpeDeviceConfigQuestion": CpeDeviceConfigQuestion,