Releasing version 2.129.2

Releasing version 2.129.2

Author: oci-dex-release-bot

CHANGELOG.rst

@@ -3,6 +3,16 @@ 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.129.2 - 2024-07-09
+====================
+
+Added
+-----
+* Support for cost management of shared resources in the Usage service
+* Support for creating new databases with oracle key vault on Exadata Cloud at Customer in the Database service
+* Support for confirming key store details on Exadata Cloud at Customer in the Database service
+
 ====================
 2.129.1 - 2024-07-02
 ====================

examples/download_manager_example.py

@@ -0,0 +1,164 @@
+import os
+import oci
+import sys
+import time
+from oci.object_storage import UploadManager
+from oci.object_storage.transfer.constants import MEBIBYTE
+from oci.object_storage.transfer.internal.download.DownloadConfiguration import DownloadConfiguration
+from oci.object_storage.transfer.internal.download.DownloadManager import DownloadManager
+from oci.object_storage.transfer.internal.download.DownloadThread import DownloadState
+from oci.retry.retry import NoneRetryStrategy, BACKOFF_FULL_JITTER_VALUE
+from oci.exceptions import ResumableDownloadException, DownloadTerminated
+
+
+def upload_progress_callback(bytes_uploaded):
+    print(f"{bytes_uploaded} additional bytes uploaded")
+
+
+def on_press(key, download_manager):
+    try:
+        if key.char == 'p':
+            if download_manager.state == 0:
+                print("Download Paused!\n")
+                download_manager.state = 1
+                return
+
+            if download_manager.state == 1:
+                print("Download Resumed!\n")
+                download_manager.state = 0
+                return
+
+        if key.char == 'q':
+            print("Terminating Download!\n")
+            download_manager.state = -1
+            return
+
+    except AttributeError:
+        pass
+
+
+def print_progress_bar(downloaded_bytes, total_bytes, bar_length=60):
+    if (total_bytes == 0):
+        print(f"Starting Download\n[{'#' * 0 + '-' * (bar_length - 0)}] {0 * 100:.2f}%")
+    else:
+        progress = downloaded_bytes / total_bytes
+        block = int(round(bar_length * progress))
+        progress_bar = f"[{'#' * block + '-' * (bar_length - block)}] {progress * 100:.2f}%"
+
+        CURSOR_UP_ONE = '\x1b[1A'
+        ERASE_LINE = '\x1b[2K'
+        sys.stdout.write(CURSOR_UP_ONE)
+        sys.stdout.write(ERASE_LINE)
+        sys.stdout.write(CURSOR_UP_ONE)
+        sys.stdout.write(ERASE_LINE)
+        print(f"Downloading: {downloaded_bytes}/{total_bytes} bytes\n{progress_bar}")
+        sys.stdout.flush()
+
+
+if __name__ == '__main__':
+    """
+    This example program works as follows.
+    1) First we upload an object to an existing bucket.
+    2) Then we download it.
+    3) While the download is in progress, press p on the keyboard to pause the download and p again to resume, q to
+    cancel the download.
+    # Please note that while the download is in progress don't type else where as the key presses will be registered as
+    pause or terminate signals.
+
+    Below are the parameters that are to be filled. Running this program in the terminal is good option as the download
+    progress is seen better that way.
+
+    PLEASE NOTE THAT THIS EXAMPLE USES pynput (pip install pynput) so it is advisable to re install all packages in the
+    requirements.txt.
+
+    Use `diff uploaded_file_name downloaded_file_name` in the terminal to check if the uploaded and downloaded files are
+    the same.
+
+    The Progress call back can add significant delays to the overall download speed.
+
+    Fill the following parameters:
+    """
+    namespace = "bm2ywytyr7us"  # Put your namespace
+    bucket_name = "bucket-20240527-1635"  # Put your bucket name
+    object_name = "11MB_dummy.txt"  # Put your object name or leave it as it is.
+    upload_filename = r'11MB_dummy.txt'
+    download2path = r'down_11MB_dummy.txt'
+    file_size_in_mebibytes = 11
+    part_size = int(1 * MEBIBYTE)
+    num_connections = 4
+
+    print(f"Part size is {part_size} MB")
+    print(f"Number of connections is {num_connections}")
+
+    object_storage_client_config = oci.config.from_file()
+
+    compartment_id = object_storage_client_config["tenancy"]
+    object_storage = oci.object_storage.ObjectStorageClient(object_storage_client_config)
+
+    # create example file to upload
+    sample_content = b'a'
+    with open(upload_filename, 'wb') as f:
+        while f.tell() < MEBIBYTE * file_size_in_mebibytes:
+            f.write(sample_content * MEBIBYTE)
+
+    print(f"Uploading new object {object_name!r}")
+
+    start_time = time.time()
+    upload_manager = UploadManager(object_storage, allow_parallel_uploads=True, parallel_process_count=num_connections)
+    response = upload_manager.upload_file(
+        namespace, bucket_name, object_name, upload_filename, part_size=part_size)
+
+    end_time = time.time()
+    print("Time taken to upload file: ", end_time - start_time)
+
+    download_configuration = DownloadConfiguration(allow_multipart=True, num_download_threads=num_connections,
+                                                   part_size_in_bytes=part_size, max_retries=1,
+                                                   backoff_type=BACKOFF_FULL_JITTER_VALUE)
+
+    download_manager = DownloadManager(download_configuration, object_storage, DownloadState.DOWNLOADING)
+
+    print_progress_bar(0, 0)
+
+    start = time.time()
+    retry_strategy = NoneRetryStrategy()
+    try:
+        bytes_written, down_response = download_manager.get_object_to_path(namespace, bucket_name, object_name,
+                                                                           download2path,
+                                                                           progress_callback=print_progress_bar)
+        end = time.time()
+        print("--------------------------------------------------------")
+        print("Download Headers:\n", down_response.headers)
+        print("Download took {} seconds".format(end - start))
+        os.remove(upload_filename)
+        os.remove(download2path)
+
+    except Exception as e:
+        exception = e
+        while True:
+            if isinstance(exception, ResumableDownloadException):
+                print("Failed parts: ", exception.failed_parts)
+                ans = (input(
+                    "Retry the failed parts parallely using resume_parts_to_path_multithread() method? [y/n] ").strip().lower())
+
+                if ans == "y":
+                    try:
+                        _ = download_manager.resume_parts_to_path_multithread(namespace, bucket_name, object_name,
+                                                                              list(exception.failed_parts.keys()),
+                                                                              download2path)
+                        os.remove(upload_filename)
+                        os.remove(download2path)
+                        break  # Exit the loop after retrying
+                    except ResumableDownloadException as e:
+                        print("ResumableDownloadException occurred again.")
+                        exception = e
+                        continue
+                    except Exception as retry_exception:
+                        raise retry_exception
+                        # Exit the loop if an unexpected exception occurs during retry
+                else:
+                    break  # Exit the loop if the user chooses not to retry
+            elif isinstance(exception, DownloadTerminated):
+                print("Download was terminated")
+                break
+            else:
+                raise exception

src/oci/database/database_client.py

@@ -4168,6 +4168,120 @@ def configure_saas_admin_user(self, autonomous_database_id, configure_saas_admin
                 api_reference_link=api_reference_link,
                 required_arguments=required_arguments)
 
+    def confirm_key_store_details_are_correct(self, key_store_id, **kwargs):
+        """
+        This is for user to confirm to DBaaS that the Oracle Key Valut (OKV) connection IPs, username and password are all correct. This operation will put
+        the Key Store back into Active state. If details are incorrect, your OKV account may get locked after some unsuccessful attempts to connect.
+
+
+        :param str key_store_id: (required)
+            The `OCID`__ of the key store.
+
+            __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
+
+        :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.
+
+        :param str if_match: (optional)
+            For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
+            parameter to the value of the etag from a previous GET or POST response for that resource.  The resource
+            will be updated or deleted only if the etag you provide matches the resource's current etag value.
+
+        :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. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
+            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`.
+
+        :param bool allow_control_chars: (optional)
+            allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
+            By default, the response will not allow control characters in strings
+
+        :return: A :class:`~oci.response.Response` object with data of type None
+        :rtype: :class:`~oci.response.Response`
+
+        :example:
+        Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/database/confirm_key_store_details_are_correct.py.html>`__ to see an example of how to use confirm_key_store_details_are_correct API.
+        """
+        # Required path and query arguments. These are in camelCase to replace values in service endpoints.
+        required_arguments = ['keyStoreId']
+        resource_path = "/keyStores/{keyStoreId}/actions/confirmDetailsAreCorrect"
+        method = "POST"
+        operation_name = "confirm_key_store_details_are_correct"
+        api_reference_link = "https://docs.oracle.com/iaas/api/#/en/database/20160918/KeyStore/ConfirmKeyStoreDetailsAreCorrect"
+
+        # Don't accept unknown kwargs
+        expected_kwargs = [
+            "allow_control_chars",
+            "retry_strategy",
+            "opc_retry_token",
+            "opc_request_id",
+            "if_match"
+        ]
+        extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
+        if extra_kwargs:
+            raise ValueError(
+                f"confirm_key_store_details_are_correct got unknown kwargs: {extra_kwargs!r}")
+
+        path_params = {
+            "keyStoreId": key_store_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(f'Parameter {k} cannot be None, whitespace or empty string')
+
+        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),
+            "if-match": kwargs.get("if_match", 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.base_client.get_preferred_retry_strategy(
+            operation_retry_strategy=kwargs.get('retry_strategy'),
+            client_retry_strategy=self.retry_strategy
+        )
+
+        if retry_strategy:
+            if not isinstance(retry_strategy, retry.NoneRetryStrategy):
+                self.base_client.add_opc_retry_token_if_needed(header_params)
+                self.base_client.add_opc_client_retries_header(header_params)
+                retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
+            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,
+                allow_control_chars=kwargs.get('allow_control_chars'),
+                operation_name=operation_name,
+                api_reference_link=api_reference_link,
+                required_arguments=required_arguments)
+        else:
+            return self.base_client.call_api(
+                resource_path=resource_path,
+                method=method,
+                path_params=path_params,
+                header_params=header_params,
+                allow_control_chars=kwargs.get('allow_control_chars'),
+                operation_name=operation_name,
+                api_reference_link=api_reference_link,
+                required_arguments=required_arguments)
+
     def convert_to_pdb(self, database_id, convert_to_pdb_details, **kwargs):
         """
         Converts a non-container database to a pluggable database.

src/oci/database/database_client_composite_operations.py

@@ -1840,6 +1840,44 @@ def configure_saas_admin_user_and_wait_for_state(self, autonomous_database_id, c
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def confirm_key_store_details_are_correct_and_wait_for_work_request(self, key_store_id, work_request_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.database.DatabaseClient.confirm_key_store_details_are_correct` and waits for the oci.work_requests.models.WorkRequest
+        to enter the given state(s).
+
+        :param str key_store_id: (required)
+            The `OCID`__ of the key store.
+
+            __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
+
+        :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.database.DatabaseClient.confirm_key_store_details_are_correct`
+
+        :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.confirm_key_store_details_are_correct(key_store_id, **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]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        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 convert_to_pdb_and_wait_for_work_request(self, database_id, convert_to_pdb_details, work_request_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.database.DatabaseClient.convert_to_pdb` and waits for the oci.work_requests.models.WorkRequest