pulumi-oci 3.6.0a1756509375__py3-none-any.whl → 3.7.0__py3-none-any.whl

pulumi_oci/mysql/_inputs.py

@@ -27,6 +27,10 @@ __all__ = [
     'ChannelTargetFilterArgsDict',
     'HeatWaveClusterClusterNodeArgs',
     'HeatWaveClusterClusterNodeArgsDict',
+    'MysqlBackupBackupValidationDetailArgs',
+    'MysqlBackupBackupValidationDetailArgsDict',
+    'MysqlBackupBackupValidationDetailPreparedBackupDetailArgs',
+    'MysqlBackupBackupValidationDetailPreparedBackupDetailArgsDict',
     'MysqlBackupDbSystemSnapshotArgs',
     'MysqlBackupDbSystemSnapshotArgsDict',
     'MysqlBackupDbSystemSnapshotBackupPolicyArgs',
@@ -57,6 +61,8 @@ __all__ = [
     'MysqlBackupEncryptDataArgsDict',
     'MysqlBackupSourceDetailsArgs',
     'MysqlBackupSourceDetailsArgsDict',
+    'MysqlBackupValidateBackupDetailArgs',
+    'MysqlBackupValidateBackupDetailArgsDict',
     'MysqlConfigurationInitVariablesArgs',
     'MysqlConfigurationInitVariablesArgsDict',
     'MysqlConfigurationVariablesArgs',
@@ -756,6 +762,190 @@ class HeatWaveClusterClusterNodeArgs:
         pulumi.set(self, "time_updated", value)
 
 
+if not MYPY:
+    class MysqlBackupBackupValidationDetailArgsDict(TypedDict):
+        backup_preparation_status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Indicates whether the backup has been prepared successfully.  PREPARED: The backup is prepared one. NOT_PREPARED: The backup is not prepared.
+        """
+        error_message: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Error message if the backup validation has failed.
+        """
+        estimated_restore_duration: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The estimated restore duration of the backup.
+        """
+        prepared_backup_details: NotRequired[pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgsDict']]]]
+        """
+        Prepared backup details.
+        """
+        time_last_validated: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The date and time of the most recent validation performed on the backup.
+        """
+        validation_status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The status of backup validation:  NOT_VALIDATED (Default): The backup has not been validated.  VALIDATED: The backup has been validated successfully.  NEEDS_ATTENTION: The backup validation failed due to a transient issue. Validation should be retried.  FAILED: The backup cannot be restored.
+        """
+elif False:
+    MysqlBackupBackupValidationDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlBackupBackupValidationDetailArgs:
+    def __init__(__self__, *,
+                 backup_preparation_status: Optional[pulumi.Input[_builtins.str]] = None,
+                 error_message: Optional[pulumi.Input[_builtins.str]] = None,
+                 estimated_restore_duration: Optional[pulumi.Input[_builtins.str]] = None,
+                 prepared_backup_details: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgs']]]] = None,
+                 time_last_validated: Optional[pulumi.Input[_builtins.str]] = None,
+                 validation_status: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] backup_preparation_status: Indicates whether the backup has been prepared successfully.  PREPARED: The backup is prepared one. NOT_PREPARED: The backup is not prepared.
+        :param pulumi.Input[_builtins.str] error_message: Error message if the backup validation has failed.
+        :param pulumi.Input[_builtins.str] estimated_restore_duration: The estimated restore duration of the backup.
+        :param pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgs']]] prepared_backup_details: Prepared backup details.
+        :param pulumi.Input[_builtins.str] time_last_validated: The date and time of the most recent validation performed on the backup.
+        :param pulumi.Input[_builtins.str] validation_status: The status of backup validation:  NOT_VALIDATED (Default): The backup has not been validated.  VALIDATED: The backup has been validated successfully.  NEEDS_ATTENTION: The backup validation failed due to a transient issue. Validation should be retried.  FAILED: The backup cannot be restored.
+        """
+        if backup_preparation_status is not None:
+            pulumi.set(__self__, "backup_preparation_status", backup_preparation_status)
+        if error_message is not None:
+            pulumi.set(__self__, "error_message", error_message)
+        if estimated_restore_duration is not None:
+            pulumi.set(__self__, "estimated_restore_duration", estimated_restore_duration)
+        if prepared_backup_details is not None:
+            pulumi.set(__self__, "prepared_backup_details", prepared_backup_details)
+        if time_last_validated is not None:
+            pulumi.set(__self__, "time_last_validated", time_last_validated)
+        if validation_status is not None:
+            pulumi.set(__self__, "validation_status", validation_status)
+
+    @_builtins.property
+    @pulumi.getter(name="backupPreparationStatus")
+    def backup_preparation_status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Indicates whether the backup has been prepared successfully.  PREPARED: The backup is prepared one. NOT_PREPARED: The backup is not prepared.
+        """
+        return pulumi.get(self, "backup_preparation_status")
+
+    @backup_preparation_status.setter
+    def backup_preparation_status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "backup_preparation_status", value)
+
+    @_builtins.property
+    @pulumi.getter(name="errorMessage")
+    def error_message(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Error message if the backup validation has failed.
+        """
+        return pulumi.get(self, "error_message")
+
+    @error_message.setter
+    def error_message(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "error_message", value)
+
+    @_builtins.property
+    @pulumi.getter(name="estimatedRestoreDuration")
+    def estimated_restore_duration(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The estimated restore duration of the backup.
+        """
+        return pulumi.get(self, "estimated_restore_duration")
+
+    @estimated_restore_duration.setter
+    def estimated_restore_duration(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "estimated_restore_duration", value)
+
+    @_builtins.property
+    @pulumi.getter(name="preparedBackupDetails")
+    def prepared_backup_details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgs']]]]:
+        """
+        Prepared backup details.
+        """
+        return pulumi.get(self, "prepared_backup_details")
+
+    @prepared_backup_details.setter
+    def prepared_backup_details(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlBackupBackupValidationDetailPreparedBackupDetailArgs']]]]):
+        pulumi.set(self, "prepared_backup_details", value)
+
+    @_builtins.property
+    @pulumi.getter(name="timeLastValidated")
+    def time_last_validated(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The date and time of the most recent validation performed on the backup.
+        """
+        return pulumi.get(self, "time_last_validated")
+
+    @time_last_validated.setter
+    def time_last_validated(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "time_last_validated", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationStatus")
+    def validation_status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The status of backup validation:  NOT_VALIDATED (Default): The backup has not been validated.  VALIDATED: The backup has been validated successfully.  NEEDS_ATTENTION: The backup validation failed due to a transient issue. Validation should be retried.  FAILED: The backup cannot be restored.
+        """
+        return pulumi.get(self, "validation_status")
+
+    @validation_status.setter
+    def validation_status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "validation_status", value)
+
+
+if not MYPY:
+    class MysqlBackupBackupValidationDetailPreparedBackupDetailArgsDict(TypedDict):
+        prepared_backup_restore_reduction_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The estimated time saving when this prepared backup is restored.
+        """
+        time_prepared: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The date and time the backup was prepared.
+        """
+elif False:
+    MysqlBackupBackupValidationDetailPreparedBackupDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlBackupBackupValidationDetailPreparedBackupDetailArgs:
+    def __init__(__self__, *,
+                 prepared_backup_restore_reduction_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
+                 time_prepared: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.int] prepared_backup_restore_reduction_in_minutes: The estimated time saving when this prepared backup is restored.
+        :param pulumi.Input[_builtins.str] time_prepared: The date and time the backup was prepared.
+        """
+        if prepared_backup_restore_reduction_in_minutes is not None:
+            pulumi.set(__self__, "prepared_backup_restore_reduction_in_minutes", prepared_backup_restore_reduction_in_minutes)
+        if time_prepared is not None:
+            pulumi.set(__self__, "time_prepared", time_prepared)
+
+    @_builtins.property
+    @pulumi.getter(name="preparedBackupRestoreReductionInMinutes")
+    def prepared_backup_restore_reduction_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The estimated time saving when this prepared backup is restored.
+        """
+        return pulumi.get(self, "prepared_backup_restore_reduction_in_minutes")
+
+    @prepared_backup_restore_reduction_in_minutes.setter
+    def prepared_backup_restore_reduction_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "prepared_backup_restore_reduction_in_minutes", value)
+
+    @_builtins.property
+    @pulumi.getter(name="timePrepared")
+    def time_prepared(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The date and time the backup was prepared.
+        """
+        return pulumi.get(self, "time_prepared")
+
+    @time_prepared.setter
+    def time_prepared(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "time_prepared", value)
+
+
 if not MYPY:
     class MysqlBackupDbSystemSnapshotArgsDict(TypedDict):
         admin_username: NotRequired[pulumi.Input[_builtins.str]]
@@ -2512,6 +2702,37 @@ class MysqlBackupSourceDetailsArgs:
         pulumi.set(self, "region", value)
 
 
+if not MYPY:
+    class MysqlBackupValidateBackupDetailArgsDict(TypedDict):
+        is_prepared_backup_required: pulumi.Input[_builtins.bool]
+        """
+        Specifies whether the backup needs to be prepared for fast restore or not. Set to true to prepare the backup **Note:** Prepare backup is a one time operation, therefore this field can be set to true only once.
+        """
+elif False:
+    MysqlBackupValidateBackupDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MysqlBackupValidateBackupDetailArgs:
+    def __init__(__self__, *,
+                 is_prepared_backup_required: pulumi.Input[_builtins.bool]):
+        """
+        :param pulumi.Input[_builtins.bool] is_prepared_backup_required: Specifies whether the backup needs to be prepared for fast restore or not. Set to true to prepare the backup **Note:** Prepare backup is a one time operation, therefore this field can be set to true only once.
+        """
+        pulumi.set(__self__, "is_prepared_backup_required", is_prepared_backup_required)
+
+    @_builtins.property
+    @pulumi.getter(name="isPreparedBackupRequired")
+    def is_prepared_backup_required(self) -> pulumi.Input[_builtins.bool]:
+        """
+        Specifies whether the backup needs to be prepared for fast restore or not. Set to true to prepare the backup **Note:** Prepare backup is a one time operation, therefore this field can be set to true only once.
+        """
+        return pulumi.get(self, "is_prepared_backup_required")
+
+    @is_prepared_backup_required.setter
+    def is_prepared_backup_required(self, value: pulumi.Input[_builtins.bool]):
+        pulumi.set(self, "is_prepared_backup_required", value)
+
+
 if not MYPY:
     class MysqlConfigurationInitVariablesArgsDict(TypedDict):
         lower_case_table_names: NotRequired[pulumi.Input[_builtins.str]]

pulumi_oci/mysql/get_mysql_backup.py

@@ -27,7 +27,7 @@ class GetMysqlBackupResult:
     """
     A collection of values returned by getMysqlBackup.
     """
-    def __init__(__self__, backup_id=None, backup_size_in_gbs=None, backup_type=None, compartment_id=None, creation_type=None, data_storage_size_in_gb=None, db_system_id=None, db_system_snapshot_summaries=None, db_system_snapshots=None, defined_tags=None, description=None, display_name=None, encrypt_datas=None, freeform_tags=None, id=None, immediate_source_backup_id=None, lifecycle_details=None, mysql_version=None, original_source_backup_id=None, retention_in_days=None, shape_name=None, soft_delete=None, source_details=None, state=None, system_tags=None, time_copy_created=None, time_created=None, time_updated=None):
+    def __init__(__self__, backup_id=None, backup_size_in_gbs=None, backup_type=None, backup_validation_details=None, compartment_id=None, creation_type=None, data_storage_size_in_gb=None, db_system_id=None, db_system_snapshot_summaries=None, db_system_snapshots=None, defined_tags=None, description=None, display_name=None, encrypt_datas=None, freeform_tags=None, id=None, immediate_source_backup_id=None, lifecycle_details=None, mysql_version=None, original_source_backup_id=None, retention_in_days=None, shape_name=None, soft_delete=None, source_details=None, state=None, system_tags=None, time_copy_created=None, time_created=None, time_updated=None, validate_backup_details=None, validate_trigger=None):
         if backup_id and not isinstance(backup_id, str):
             raise TypeError("Expected argument 'backup_id' to be a str")
         pulumi.set(__self__, "backup_id", backup_id)
@@ -37,6 +37,9 @@ class GetMysqlBackupResult:
         if backup_type and not isinstance(backup_type, str):
             raise TypeError("Expected argument 'backup_type' to be a str")
         pulumi.set(__self__, "backup_type", backup_type)
+        if backup_validation_details and not isinstance(backup_validation_details, list):
+            raise TypeError("Expected argument 'backup_validation_details' to be a list")
+        pulumi.set(__self__, "backup_validation_details", backup_validation_details)
         if compartment_id and not isinstance(compartment_id, str):
             raise TypeError("Expected argument 'compartment_id' to be a str")
         pulumi.set(__self__, "compartment_id", compartment_id)
@@ -112,6 +115,12 @@ class GetMysqlBackupResult:
         if time_updated and not isinstance(time_updated, str):
             raise TypeError("Expected argument 'time_updated' to be a str")
         pulumi.set(__self__, "time_updated", time_updated)
+        if validate_backup_details and not isinstance(validate_backup_details, list):
+            raise TypeError("Expected argument 'validate_backup_details' to be a list")
+        pulumi.set(__self__, "validate_backup_details", validate_backup_details)
+        if validate_trigger and not isinstance(validate_trigger, int):
+            raise TypeError("Expected argument 'validate_trigger' to be a int")
+        pulumi.set(__self__, "validate_trigger", validate_trigger)
 
     @_builtins.property
     @pulumi.getter(name="backupId")
@@ -134,6 +143,14 @@ class GetMysqlBackupResult:
         """
         return pulumi.get(self, "backup_type")
 
+    @_builtins.property
+    @pulumi.getter(name="backupValidationDetails")
+    def backup_validation_details(self) -> Sequence['outputs.GetMysqlBackupBackupValidationDetailResult']:
+        """
+        Backup validation details.
+        """
+        return pulumi.get(self, "backup_validation_details")
+
     @_builtins.property
     @pulumi.getter(name="compartmentId")
     def compartment_id(self) -> _builtins.str:
@@ -328,6 +345,16 @@ class GetMysqlBackupResult:
         """
         return pulumi.get(self, "time_updated")
 
+    @_builtins.property
+    @pulumi.getter(name="validateBackupDetails")
+    def validate_backup_details(self) -> Sequence['outputs.GetMysqlBackupValidateBackupDetailResult']:
+        return pulumi.get(self, "validate_backup_details")
+
+    @_builtins.property
+    @pulumi.getter(name="validateTrigger")
+    def validate_trigger(self) -> _builtins.int:
+        return pulumi.get(self, "validate_trigger")
+
 
 class AwaitableGetMysqlBackupResult(GetMysqlBackupResult):
     # pylint: disable=using-constant-test
@@ -338,6 +365,7 @@ class AwaitableGetMysqlBackupResult(GetMysqlBackupResult):
             backup_id=self.backup_id,
             backup_size_in_gbs=self.backup_size_in_gbs,
             backup_type=self.backup_type,
+            backup_validation_details=self.backup_validation_details,
             compartment_id=self.compartment_id,
             creation_type=self.creation_type,
             data_storage_size_in_gb=self.data_storage_size_in_gb,
@@ -362,7 +390,9 @@ class AwaitableGetMysqlBackupResult(GetMysqlBackupResult):
             system_tags=self.system_tags,
             time_copy_created=self.time_copy_created,
             time_created=self.time_created,
-            time_updated=self.time_updated)
+            time_updated=self.time_updated,
+            validate_backup_details=self.validate_backup_details,
+            validate_trigger=self.validate_trigger)
 
 
 def get_mysql_backup(backup_id: Optional[_builtins.str] = None,
@@ -393,6 +423,7 @@ def get_mysql_backup(backup_id: Optional[_builtins.str] = None,
         backup_id=pulumi.get(__ret__, 'backup_id'),
         backup_size_in_gbs=pulumi.get(__ret__, 'backup_size_in_gbs'),
         backup_type=pulumi.get(__ret__, 'backup_type'),
+        backup_validation_details=pulumi.get(__ret__, 'backup_validation_details'),
         compartment_id=pulumi.get(__ret__, 'compartment_id'),
         creation_type=pulumi.get(__ret__, 'creation_type'),
         data_storage_size_in_gb=pulumi.get(__ret__, 'data_storage_size_in_gb'),
@@ -417,7 +448,9 @@ def get_mysql_backup(backup_id: Optional[_builtins.str] = None,
         system_tags=pulumi.get(__ret__, 'system_tags'),
         time_copy_created=pulumi.get(__ret__, 'time_copy_created'),
         time_created=pulumi.get(__ret__, 'time_created'),
-        time_updated=pulumi.get(__ret__, 'time_updated'))
+        time_updated=pulumi.get(__ret__, 'time_updated'),
+        validate_backup_details=pulumi.get(__ret__, 'validate_backup_details'),
+        validate_trigger=pulumi.get(__ret__, 'validate_trigger'))
 def get_mysql_backup_output(backup_id: Optional[pulumi.Input[_builtins.str]] = None,
                             opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetMysqlBackupResult]:
     """
@@ -445,6 +478,7 @@ def get_mysql_backup_output(backup_id: Optional[pulumi.Input[_builtins.str]] = N
         backup_id=pulumi.get(__response__, 'backup_id'),
         backup_size_in_gbs=pulumi.get(__response__, 'backup_size_in_gbs'),
         backup_type=pulumi.get(__response__, 'backup_type'),
+        backup_validation_details=pulumi.get(__response__, 'backup_validation_details'),
         compartment_id=pulumi.get(__response__, 'compartment_id'),
         creation_type=pulumi.get(__response__, 'creation_type'),
         data_storage_size_in_gb=pulumi.get(__response__, 'data_storage_size_in_gb'),
@@ -469,4 +503,6 @@ def get_mysql_backup_output(backup_id: Optional[pulumi.Input[_builtins.str]] = N
         system_tags=pulumi.get(__response__, 'system_tags'),
         time_copy_created=pulumi.get(__response__, 'time_copy_created'),
         time_created=pulumi.get(__response__, 'time_created'),
-        time_updated=pulumi.get(__response__, 'time_updated')))
+        time_updated=pulumi.get(__response__, 'time_updated'),
+        validate_backup_details=pulumi.get(__response__, 'validate_backup_details'),
+        validate_trigger=pulumi.get(__response__, 'validate_trigger')))

pulumi_oci/mysql/get_mysql_backups.py

@@ -174,7 +174,7 @@ def get_mysql_backups(backup_id: Optional[_builtins.str] = None,
     import pulumi_oci as oci
 
     test_mysql_backups = oci.Mysql.get_mysql_backups(compartment_id=compartment_id,
-        backup_id=test_backup["id"],
+        backup_id=test_mysql_backup["id"],
         creation_type=mysql_backup_creation_type,
         db_system_id=test_db_system["id"],
         display_name=mysql_backup_display_name,
@@ -235,7 +235,7 @@ def get_mysql_backups_output(backup_id: Optional[pulumi.Input[Optional[_builtins
     import pulumi_oci as oci
 
     test_mysql_backups = oci.Mysql.get_mysql_backups(compartment_id=compartment_id,
-        backup_id=test_backup["id"],
+        backup_id=test_mysql_backup["id"],
         creation_type=mysql_backup_creation_type,
         db_system_id=test_db_system["id"],
         display_name=mysql_backup_display_name,