pulumi-oci 2.8.0a1724220787__py3-none-any.whl → 2.9.0__py3-none-any.whl

pulumi_oci/mysql/_inputs.py

@@ -19,6 +19,7 @@ __all__ = [
     'MysqlBackupDbSystemSnapshotArgs',
     'MysqlBackupDbSystemSnapshotBackupPolicyArgs',
     'MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs',
+    'MysqlBackupDbSystemSnapshotDataStorageArgs',
     'MysqlBackupDbSystemSnapshotDeletionPolicyArgs',
     'MysqlBackupDbSystemSnapshotEndpointArgs',
     'MysqlBackupDbSystemSnapshotMaintenanceArgs',
@@ -36,6 +37,8 @@ __all__ = [
     'MysqlDbSystemChannelTargetArgs',
     'MysqlDbSystemChannelTargetFilterArgs',
     'MysqlDbSystemCurrentPlacementArgs',
+    'MysqlDbSystemCustomerContactArgs',
+    'MysqlDbSystemDataStorageArgs',
     'MysqlDbSystemDeletionPolicyArgs',
     'MysqlDbSystemEndpointArgs',
     'MysqlDbSystemHeatWaveClusterArgs',
@@ -544,6 +547,7 @@ class MysqlBackupDbSystemSnapshotArgs:
                  configuration_id: Optional[pulumi.Input[str]] = None,
                  crash_recovery: Optional[pulumi.Input[str]] = None,
                  data_storage_size_in_gb: Optional[pulumi.Input[int]] = None,
+                 data_storages: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotDataStorageArgs']]]] = None,
                  database_management: Optional[pulumi.Input[str]] = None,
                  defined_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  deletion_policies: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotDeletionPolicyArgs']]]] = None,
@@ -571,7 +575,8 @@ class MysqlBackupDbSystemSnapshotArgs:
         :param pulumi.Input[str] compartment_id: (Updatable) The OCID of the compartment the backup exists in.
         :param pulumi.Input[str] configuration_id: The OCID of the Configuration to be used for Instances in this DB System.
         :param pulumi.Input[str] crash_recovery: Whether to run the DB System with InnoDB Redo Logs and the Double Write Buffer enabled or disabled, and whether to enable or disable syncing of the Binary Logs.
-        :param pulumi.Input[int] data_storage_size_in_gb: Initial size of the data volume in GiBs that will be created and attached.
+        :param pulumi.Input[int] data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotDataStorageArgs']]] data_storages: Data Storage information.
         :param pulumi.Input[str] database_management: Whether to enable monitoring via the Database Management service.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] defined_tags: (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
         :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotDeletionPolicyArgs']]] deletion_policies: The Deletion policy for the DB System.
@@ -607,6 +612,8 @@ class MysqlBackupDbSystemSnapshotArgs:
             pulumi.set(__self__, "crash_recovery", crash_recovery)
         if data_storage_size_in_gb is not None:
             pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        if data_storages is not None:
+            pulumi.set(__self__, "data_storages", data_storages)
         if database_management is not None:
             pulumi.set(__self__, "database_management", database_management)
         if defined_tags is not None:
@@ -724,7 +731,7 @@ class MysqlBackupDbSystemSnapshotArgs:
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> Optional[pulumi.Input[int]]:
         """
-        Initial size of the data volume in GiBs that will be created and attached.
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         """
         return pulumi.get(self, "data_storage_size_in_gb")
 
@@ -732,6 +739,18 @@ class MysqlBackupDbSystemSnapshotArgs:
     def data_storage_size_in_gb(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "data_storage_size_in_gb", value)
 
+    @property
+    @pulumi.getter(name="dataStorages")
+    def data_storages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotDataStorageArgs']]]]:
+        """
+        Data Storage information.
+        """
+        return pulumi.get(self, "data_storages")
+
+    @data_storages.setter
+    def data_storages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotDataStorageArgs']]]]):
+        pulumi.set(self, "data_storages", value)
+
     @property
     @pulumi.getter(name="databaseManagement")
     def database_management(self) -> Optional[pulumi.Input[str]]:
@@ -1099,6 +1118,93 @@ class MysqlBackupDbSystemSnapshotBackupPolicyPitrPolicyArgs:
         pulumi.set(self, "is_enabled", value)
 
 
+@pulumi.input_type
+class MysqlBackupDbSystemSnapshotDataStorageArgs:
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: Optional[pulumi.Input[int]] = None,
+                 data_storage_size_in_gb: Optional[pulumi.Input[int]] = None,
+                 data_storage_size_limit_in_gbs: Optional[pulumi.Input[int]] = None,
+                 is_auto_expand_storage_enabled: Optional[pulumi.Input[bool]] = None,
+                 max_storage_size_in_gbs: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] allocated_storage_size_in_gbs: The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        :param pulumi.Input[int] data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        :param pulumi.Input[int] data_storage_size_limit_in_gbs: The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        :param pulumi.Input[bool] is_auto_expand_storage_enabled: Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        :param pulumi.Input[int] max_storage_size_in_gbs: Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        if allocated_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        if data_storage_size_in_gb is not None:
+            pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        if data_storage_size_limit_in_gbs is not None:
+            pulumi.set(__self__, "data_storage_size_limit_in_gbs", data_storage_size_limit_in_gbs)
+        if is_auto_expand_storage_enabled is not None:
+            pulumi.set(__self__, "is_auto_expand_storage_enabled", is_auto_expand_storage_enabled)
+        if max_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "max_storage_size_in_gbs", max_storage_size_in_gbs)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @allocated_storage_size_in_gbs.setter
+    def allocated_storage_size_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "allocated_storage_size_in_gbs", value)
+
+    @property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> Optional[pulumi.Input[int]]:
+        """
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @data_storage_size_in_gb.setter
+    def data_storage_size_in_gb(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "data_storage_size_in_gb", value)
+
+    @property
+    @pulumi.getter(name="dataStorageSizeLimitInGbs")
+    def data_storage_size_limit_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        """
+        return pulumi.get(self, "data_storage_size_limit_in_gbs")
+
+    @data_storage_size_limit_in_gbs.setter
+    def data_storage_size_limit_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "data_storage_size_limit_in_gbs", value)
+
+    @property
+    @pulumi.getter(name="isAutoExpandStorageEnabled")
+    def is_auto_expand_storage_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        """
+        return pulumi.get(self, "is_auto_expand_storage_enabled")
+
+    @is_auto_expand_storage_enabled.setter
+    def is_auto_expand_storage_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_auto_expand_storage_enabled", value)
+
+    @property
+    @pulumi.getter(name="maxStorageSizeInGbs")
+    def max_storage_size_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+        """
+        return pulumi.get(self, "max_storage_size_in_gbs")
+
+    @max_storage_size_in_gbs.setter
+    def max_storage_size_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_storage_size_in_gbs", value)
+
+
 @pulumi.input_type
 class MysqlBackupDbSystemSnapshotDeletionPolicyArgs:
     def __init__(__self__, *,
@@ -3783,6 +3889,123 @@ class MysqlDbSystemCurrentPlacementArgs:
         pulumi.set(self, "fault_domain", value)
 
 
+@pulumi.input_type
+class MysqlDbSystemCustomerContactArgs:
+    def __init__(__self__, *,
+                 email: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] email: (Updatable) The email address used by Oracle to send notifications regarding the DB System.
+        """
+        pulumi.set(__self__, "email", email)
+
+    @property
+    @pulumi.getter
+    def email(self) -> pulumi.Input[str]:
+        """
+        (Updatable) The email address used by Oracle to send notifications regarding the DB System.
+        """
+        return pulumi.get(self, "email")
+
+    @email.setter
+    def email(self, value: pulumi.Input[str]):
+        pulumi.set(self, "email", value)
+
+
+@pulumi.input_type
+class MysqlDbSystemDataStorageArgs:
+    def __init__(__self__, *,
+                 allocated_storage_size_in_gbs: Optional[pulumi.Input[int]] = None,
+                 data_storage_size_in_gb: Optional[pulumi.Input[int]] = None,
+                 data_storage_size_limit_in_gbs: Optional[pulumi.Input[int]] = None,
+                 is_auto_expand_storage_enabled: Optional[pulumi.Input[bool]] = None,
+                 max_storage_size_in_gbs: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] allocated_storage_size_in_gbs: The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        :param pulumi.Input[int] data_storage_size_in_gb: (Updatable) Initial size of the data volume in GBs that will be created and attached. Keep in mind that this only specifies the size of the database data volume, the log volume for the database will be scaled appropriately with its shape. It is required if you are creating a new database. It cannot be set if you are creating a database from a backup.
+        :param pulumi.Input[int] data_storage_size_limit_in_gbs: The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        :param pulumi.Input[bool] is_auto_expand_storage_enabled: (Updatable) Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        :param pulumi.Input[int] max_storage_size_in_gbs: (Updatable) Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+               
+               DB Systems with an initial storage size of 400 GB or less can be expanded up to 32 TB. DB Systems with an initial storage size between 401-800 GB can be expanded up to 64 TB. DB Systems with an initial storage size between 801-1200 GB can be expanded up to 96 TB. DB Systems with an initial storage size of 1201 GB or more can be expanded up to 128 TB.
+               
+               It is not possible to decrease data storage size. You cannot set the maximum data storage size to less than either current DB System dataStorageSizeInGBs or allocatedStorageSizeInGBs.
+        """
+        if allocated_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "allocated_storage_size_in_gbs", allocated_storage_size_in_gbs)
+        if data_storage_size_in_gb is not None:
+            pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        if data_storage_size_limit_in_gbs is not None:
+            pulumi.set(__self__, "data_storage_size_limit_in_gbs", data_storage_size_limit_in_gbs)
+        if is_auto_expand_storage_enabled is not None:
+            pulumi.set(__self__, "is_auto_expand_storage_enabled", is_auto_expand_storage_enabled)
+        if max_storage_size_in_gbs is not None:
+            pulumi.set(__self__, "max_storage_size_in_gbs", max_storage_size_in_gbs)
+
+    @property
+    @pulumi.getter(name="allocatedStorageSizeInGbs")
+    def allocated_storage_size_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        The actual allocated storage size for the DB System. This may be higher than dataStorageSizeInGBs if an automatic storage expansion has occurred.
+        """
+        return pulumi.get(self, "allocated_storage_size_in_gbs")
+
+    @allocated_storage_size_in_gbs.setter
+    def allocated_storage_size_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "allocated_storage_size_in_gbs", value)
+
+    @property
+    @pulumi.getter(name="dataStorageSizeInGb")
+    def data_storage_size_in_gb(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) Initial size of the data volume in GBs that will be created and attached. Keep in mind that this only specifies the size of the database data volume, the log volume for the database will be scaled appropriately with its shape. It is required if you are creating a new database. It cannot be set if you are creating a database from a backup.
+        """
+        return pulumi.get(self, "data_storage_size_in_gb")
+
+    @data_storage_size_in_gb.setter
+    def data_storage_size_in_gb(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "data_storage_size_in_gb", value)
+
+    @property
+    @pulumi.getter(name="dataStorageSizeLimitInGbs")
+    def data_storage_size_limit_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        The absolute limit the DB System's storage size may ever expand to, either manually or automatically. This limit is based based on the initial dataStorageSizeInGBs when the DB System was first created. Both dataStorageSizeInGBs and maxDataStorageSizeInGBs can not exceed this value.
+        """
+        return pulumi.get(self, "data_storage_size_limit_in_gbs")
+
+    @data_storage_size_limit_in_gbs.setter
+    def data_storage_size_limit_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "data_storage_size_limit_in_gbs", value)
+
+    @property
+    @pulumi.getter(name="isAutoExpandStorageEnabled")
+    def is_auto_expand_storage_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) Enable/disable automatic storage expansion. When set to true, the DB System will automatically add storage incrementally up to the value specified in maxStorageSizeInGBs.
+        """
+        return pulumi.get(self, "is_auto_expand_storage_enabled")
+
+    @is_auto_expand_storage_enabled.setter
+    def is_auto_expand_storage_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_auto_expand_storage_enabled", value)
+
+    @property
+    @pulumi.getter(name="maxStorageSizeInGbs")
+    def max_storage_size_in_gbs(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) Maximum storage size this DB System can expand to. When isAutoExpandStorageEnabled is set to true, the DB System will add storage incrementally up to this value.
+
+        DB Systems with an initial storage size of 400 GB or less can be expanded up to 32 TB. DB Systems with an initial storage size between 401-800 GB can be expanded up to 64 TB. DB Systems with an initial storage size between 801-1200 GB can be expanded up to 96 TB. DB Systems with an initial storage size of 1201 GB or more can be expanded up to 128 TB.
+
+        It is not possible to decrease data storage size. You cannot set the maximum data storage size to less than either current DB System dataStorageSizeInGBs or allocatedStorageSizeInGBs.
+        """
+        return pulumi.get(self, "max_storage_size_in_gbs")
+
+    @max_storage_size_in_gbs.setter
+    def max_storage_size_in_gbs(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_storage_size_in_gbs", value)
+
+
 @pulumi.input_type
 class MysqlDbSystemDeletionPolicyArgs:
     def __init__(__self__, *,

pulumi_oci/mysql/get_mysql_backup.py

@@ -140,7 +140,7 @@ class GetMysqlBackupResult:
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> int:
         """
-        Initial size of the data volume in GiBs that will be created and attached.
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         """
         return pulumi.get(self, "data_storage_size_in_gb")
 

pulumi_oci/mysql/get_mysql_db_system.py

@@ -22,7 +22,7 @@ class GetMysqlDbSystemResult:
     """
     A collection of values returned by getMysqlDbSystem.
     """
-    def __init__(__self__, admin_password=None, admin_username=None, availability_domain=None, backup_policies=None, channels=None, compartment_id=None, configuration_id=None, crash_recovery=None, current_placements=None, data_storage_size_in_gb=None, database_management=None, db_system_id=None, defined_tags=None, deletion_policies=None, description=None, display_name=None, endpoints=None, fault_domain=None, freeform_tags=None, heat_wave_clusters=None, hostname_label=None, id=None, ip_address=None, is_heat_wave_cluster_attached=None, is_highly_available=None, lifecycle_details=None, maintenances=None, mysql_version=None, point_in_time_recovery_details=None, port=None, port_x=None, secure_connections=None, shape_name=None, shutdown_type=None, sources=None, state=None, subnet_id=None, time_created=None, time_updated=None):
+    def __init__(__self__, admin_password=None, admin_username=None, availability_domain=None, backup_policies=None, channels=None, compartment_id=None, configuration_id=None, crash_recovery=None, current_placements=None, customer_contacts=None, data_storage_size_in_gb=None, data_storages=None, database_management=None, db_system_id=None, defined_tags=None, deletion_policies=None, description=None, display_name=None, endpoints=None, fault_domain=None, freeform_tags=None, heat_wave_clusters=None, hostname_label=None, id=None, ip_address=None, is_heat_wave_cluster_attached=None, is_highly_available=None, lifecycle_details=None, maintenances=None, mysql_version=None, point_in_time_recovery_details=None, port=None, port_x=None, secure_connections=None, shape_name=None, shutdown_type=None, sources=None, state=None, subnet_id=None, time_created=None, time_updated=None):
         if admin_password and not isinstance(admin_password, str):
             raise TypeError("Expected argument 'admin_password' to be a str")
         pulumi.set(__self__, "admin_password", admin_password)
@@ -50,9 +50,15 @@ class GetMysqlDbSystemResult:
         if current_placements and not isinstance(current_placements, list):
             raise TypeError("Expected argument 'current_placements' to be a list")
         pulumi.set(__self__, "current_placements", current_placements)
+        if customer_contacts and not isinstance(customer_contacts, list):
+            raise TypeError("Expected argument 'customer_contacts' to be a list")
+        pulumi.set(__self__, "customer_contacts", customer_contacts)
         if data_storage_size_in_gb and not isinstance(data_storage_size_in_gb, int):
             raise TypeError("Expected argument 'data_storage_size_in_gb' to be a int")
         pulumi.set(__self__, "data_storage_size_in_gb", data_storage_size_in_gb)
+        if data_storages and not isinstance(data_storages, list):
+            raise TypeError("Expected argument 'data_storages' to be a list")
+        pulumi.set(__self__, "data_storages", data_storages)
         if database_management and not isinstance(database_management, str):
             raise TypeError("Expected argument 'database_management' to be a str")
         pulumi.set(__self__, "database_management", database_management)
@@ -207,6 +213,14 @@ class GetMysqlDbSystemResult:
         """
         return pulumi.get(self, "current_placements")
 
+    @property
+    @pulumi.getter(name="customerContacts")
+    def customer_contacts(self) -> Sequence['outputs.GetMysqlDbSystemCustomerContactResult']:
+        """
+        The list of customer email addresses that receive information from Oracle about the specified Oracle Cloud Infrastructure DB System resource.  Oracle uses these email addresses to send notifications about planned and unplanned software maintenance updates, information about system hardware, and other information needed by administrators.  Up to 10 email addresses can be added to the customer contacts for a DB System.
+        """
+        return pulumi.get(self, "customer_contacts")
+
     @property
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> int:
@@ -215,6 +229,14 @@ class GetMysqlDbSystemResult:
         """
         return pulumi.get(self, "data_storage_size_in_gb")
 
+    @property
+    @pulumi.getter(name="dataStorages")
+    def data_storages(self) -> Sequence['outputs.GetMysqlDbSystemDataStorageResult']:
+        """
+        Data Storage information.
+        """
+        return pulumi.get(self, "data_storages")
+
     @property
     @pulumi.getter(name="databaseManagement")
     def database_management(self) -> str:
@@ -460,7 +482,9 @@ class AwaitableGetMysqlDbSystemResult(GetMysqlDbSystemResult):
             configuration_id=self.configuration_id,
             crash_recovery=self.crash_recovery,
             current_placements=self.current_placements,
+            customer_contacts=self.customer_contacts,
             data_storage_size_in_gb=self.data_storage_size_in_gb,
+            data_storages=self.data_storages,
             database_management=self.database_management,
             db_system_id=self.db_system_id,
             defined_tags=self.defined_tags,
@@ -526,7 +550,9 @@ def get_mysql_db_system(db_system_id: Optional[str] = None,
         configuration_id=pulumi.get(__ret__, 'configuration_id'),
         crash_recovery=pulumi.get(__ret__, 'crash_recovery'),
         current_placements=pulumi.get(__ret__, 'current_placements'),
+        customer_contacts=pulumi.get(__ret__, 'customer_contacts'),
         data_storage_size_in_gb=pulumi.get(__ret__, 'data_storage_size_in_gb'),
+        data_storages=pulumi.get(__ret__, 'data_storages'),
         database_management=pulumi.get(__ret__, 'database_management'),
         db_system_id=pulumi.get(__ret__, 'db_system_id'),
         defined_tags=pulumi.get(__ret__, 'defined_tags'),

pulumi_oci/mysql/mysql_backup.py

@@ -209,7 +209,7 @@ class _MysqlBackupState:
         :param pulumi.Input[str] backup_type: The type of backup.
         :param pulumi.Input[str] compartment_id: (Updatable) The OCID of the compartment the backup exists in.
         :param pulumi.Input[str] creation_type: Indicates how the backup was created: manually, automatic, or by an Operator.
-        :param pulumi.Input[int] data_storage_size_in_gb: Initial size of the data volume in GiBs that will be created and attached.
+        :param pulumi.Input[int] data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         :param pulumi.Input[str] db_system_id: The OCID of the DB System the Backup is associated with.
         :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupDbSystemSnapshotArgs']]] db_system_snapshots: Snapshot of the DbSystem details at the time of the backup
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] defined_tags: (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
@@ -327,7 +327,7 @@ class _MysqlBackupState:
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> Optional[pulumi.Input[int]]:
         """
-        Initial size of the data volume in GiBs that will be created and attached.
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         """
         return pulumi.get(self, "data_storage_size_in_gb")
 
@@ -750,7 +750,7 @@ class MysqlBackup(pulumi.CustomResource):
         :param pulumi.Input[str] backup_type: The type of backup.
         :param pulumi.Input[str] compartment_id: (Updatable) The OCID of the compartment the backup exists in.
         :param pulumi.Input[str] creation_type: Indicates how the backup was created: manually, automatic, or by an Operator.
-        :param pulumi.Input[int] data_storage_size_in_gb: Initial size of the data volume in GiBs that will be created and attached.
+        :param pulumi.Input[int] data_storage_size_in_gb: DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         :param pulumi.Input[str] db_system_id: The OCID of the DB System the Backup is associated with.
         :param pulumi.Input[Sequence[pulumi.Input[Union['MysqlBackupDbSystemSnapshotArgs', 'MysqlBackupDbSystemSnapshotArgsDict']]]] db_system_snapshots: Snapshot of the DbSystem details at the time of the backup
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] defined_tags: (Updatable) Defined tags for this resource. Each key is predefined and scoped to a namespace. Example: `{"foo-namespace.bar-key": "value"}`
@@ -834,7 +834,7 @@ class MysqlBackup(pulumi.CustomResource):
     @pulumi.getter(name="dataStorageSizeInGb")
     def data_storage_size_in_gb(self) -> pulumi.Output[int]:
         """
-        Initial size of the data volume in GiBs that will be created and attached.
+        DEPRECATED: User specified size of the data volume. May be less than current allocatedStorageSizeInGBs. Replaced by dataStorage.dataStorageSizeInGBs.
         """
         return pulumi.get(self, "data_storage_size_in_gb")