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

pulumi_oci/recoverymod/get_protected_database.py

@@ -22,7 +22,7 @@ class GetProtectedDatabaseResult:
     """
     A collection of values returned by getProtectedDatabase.
     """
-    def __init__(__self__, compartment_id=None, database_id=None, database_size=None, db_unique_name=None, defined_tags=None, deletion_schedule=None, display_name=None, freeform_tags=None, health=None, health_details=None, id=None, is_read_only_resource=None, is_redo_logs_shipped=None, lifecycle_details=None, metrics=None, password=None, policy_locked_date_time=None, protected_database_id=None, protection_policy_id=None, recovery_service_subnets=None, state=None, system_tags=None, time_created=None, time_updated=None, vpc_user_name=None):
+    def __init__(__self__, compartment_id=None, database_id=None, database_size=None, db_unique_name=None, defined_tags=None, deletion_schedule=None, display_name=None, freeform_tags=None, health=None, health_details=None, id=None, is_read_only_resource=None, is_redo_logs_shipped=None, lifecycle_details=None, metrics=None, password=None, policy_locked_date_time=None, protected_database_id=None, protection_policy_id=None, recovery_service_subnets=None, state=None, subscription_id=None, system_tags=None, time_created=None, time_updated=None, vpc_user_name=None):
         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)
@@ -86,6 +86,9 @@ class GetProtectedDatabaseResult:
         if state and not isinstance(state, str):
             raise TypeError("Expected argument 'state' to be a str")
         pulumi.set(__self__, "state", state)
+        if subscription_id and not isinstance(subscription_id, str):
+            raise TypeError("Expected argument 'subscription_id' to be a str")
+        pulumi.set(__self__, "subscription_id", subscription_id)
         if system_tags and not isinstance(system_tags, dict):
             raise TypeError("Expected argument 'system_tags' to be a dict")
         pulumi.set(__self__, "system_tags", system_tags)
@@ -258,6 +261,14 @@ class GetProtectedDatabaseResult:
         """
         return pulumi.get(self, "state")
 
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> str:
+        """
+        The OCID of the cloud service subscription to which the protected database is linked.
+        """
+        return pulumi.get(self, "subscription_id")
+
     @property
     @pulumi.getter(name="systemTags")
     def system_tags(self) -> Mapping[str, str]:
@@ -318,6 +329,7 @@ class AwaitableGetProtectedDatabaseResult(GetProtectedDatabaseResult):
             protection_policy_id=self.protection_policy_id,
             recovery_service_subnets=self.recovery_service_subnets,
             state=self.state,
+            subscription_id=self.subscription_id,
             system_tags=self.system_tags,
             time_created=self.time_created,
             time_updated=self.time_updated,
@@ -370,6 +382,7 @@ def get_protected_database(protected_database_id: Optional[str] = None,
         protection_policy_id=pulumi.get(__ret__, 'protection_policy_id'),
         recovery_service_subnets=pulumi.get(__ret__, 'recovery_service_subnets'),
         state=pulumi.get(__ret__, 'state'),
+        subscription_id=pulumi.get(__ret__, 'subscription_id'),
         system_tags=pulumi.get(__ret__, 'system_tags'),
         time_created=pulumi.get(__ret__, 'time_created'),
         time_updated=pulumi.get(__ret__, 'time_updated'),

pulumi_oci/recoverymod/get_protection_policy.py

@@ -21,7 +21,7 @@ class GetProtectionPolicyResult:
     """
     A collection of values returned by getProtectionPolicy.
     """
-    def __init__(__self__, backup_retention_period_in_days=None, compartment_id=None, defined_tags=None, display_name=None, freeform_tags=None, id=None, is_predefined_policy=None, lifecycle_details=None, policy_locked_date_time=None, protection_policy_id=None, state=None, system_tags=None, time_created=None, time_updated=None):
+    def __init__(__self__, backup_retention_period_in_days=None, compartment_id=None, defined_tags=None, display_name=None, freeform_tags=None, id=None, is_predefined_policy=None, lifecycle_details=None, must_enforce_cloud_locality=None, policy_locked_date_time=None, protection_policy_id=None, state=None, system_tags=None, time_created=None, time_updated=None):
         if backup_retention_period_in_days and not isinstance(backup_retention_period_in_days, int):
             raise TypeError("Expected argument 'backup_retention_period_in_days' to be a int")
         pulumi.set(__self__, "backup_retention_period_in_days", backup_retention_period_in_days)
@@ -46,6 +46,9 @@ class GetProtectionPolicyResult:
         if lifecycle_details and not isinstance(lifecycle_details, str):
             raise TypeError("Expected argument 'lifecycle_details' to be a str")
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        if must_enforce_cloud_locality and not isinstance(must_enforce_cloud_locality, bool):
+            raise TypeError("Expected argument 'must_enforce_cloud_locality' to be a bool")
+        pulumi.set(__self__, "must_enforce_cloud_locality", must_enforce_cloud_locality)
         if policy_locked_date_time and not isinstance(policy_locked_date_time, str):
             raise TypeError("Expected argument 'policy_locked_date_time' to be a str")
         pulumi.set(__self__, "policy_locked_date_time", policy_locked_date_time)
@@ -129,6 +132,14 @@ class GetProtectionPolicyResult:
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="mustEnforceCloudLocality")
+    def must_enforce_cloud_locality(self) -> bool:
+        """
+        Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned.
+        """
+        return pulumi.get(self, "must_enforce_cloud_locality")
+
     @property
     @pulumi.getter(name="policyLockedDateTime")
     def policy_locked_date_time(self) -> str:
@@ -189,6 +200,7 @@ class AwaitableGetProtectionPolicyResult(GetProtectionPolicyResult):
             id=self.id,
             is_predefined_policy=self.is_predefined_policy,
             lifecycle_details=self.lifecycle_details,
+            must_enforce_cloud_locality=self.must_enforce_cloud_locality,
             policy_locked_date_time=self.policy_locked_date_time,
             protection_policy_id=self.protection_policy_id,
             state=self.state,
@@ -230,6 +242,7 @@ def get_protection_policy(protection_policy_id: Optional[str] = None,
         id=pulumi.get(__ret__, 'id'),
         is_predefined_policy=pulumi.get(__ret__, 'is_predefined_policy'),
         lifecycle_details=pulumi.get(__ret__, 'lifecycle_details'),
+        must_enforce_cloud_locality=pulumi.get(__ret__, 'must_enforce_cloud_locality'),
         policy_locked_date_time=pulumi.get(__ret__, 'policy_locked_date_time'),
         protection_policy_id=pulumi.get(__ret__, 'protection_policy_id'),
         state=pulumi.get(__ret__, 'state'),

pulumi_oci/recoverymod/outputs.py

@@ -186,10 +186,6 @@ class ProtectedDatabaseRecoveryServiceSubnet(dict):
                  state: Optional[str] = None):
         """
         :param str recovery_service_subnet_id: (Updatable) The recovery service subnet OCID.
-               
-               
-               ** IMPORTANT **
-               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         :param str state: The current state of the Protected Database.
         """
         pulumi.set(__self__, "recovery_service_subnet_id", recovery_service_subnet_id)
@@ -201,10 +197,6 @@ class ProtectedDatabaseRecoveryServiceSubnet(dict):
     def recovery_service_subnet_id(self) -> str:
         """
         (Updatable) The recovery service subnet OCID.
-
-
-        ** IMPORTANT **
-        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         """
         return pulumi.get(self, "recovery_service_subnet_id")
 
@@ -403,6 +395,7 @@ class GetProtectedDatabasesProtectedDatabaseCollectionItemResult(dict):
                  protection_policy_id: str,
                  recovery_service_subnets: Sequence['outputs.GetProtectedDatabasesProtectedDatabaseCollectionItemRecoveryServiceSubnetResult'],
                  state: str,
+                 subscription_id: str,
                  system_tags: Mapping[str, str],
                  time_created: str,
                  time_updated: str,
@@ -426,6 +419,7 @@ class GetProtectedDatabasesProtectedDatabaseCollectionItemResult(dict):
         :param str protection_policy_id: The protection policy OCID.
         :param Sequence['GetProtectedDatabasesProtectedDatabaseCollectionItemRecoveryServiceSubnetArgs'] recovery_service_subnets: List of recovery service subnet resources associated with the protected database.
         :param str state: A filter to return only the resources that match the specified lifecycle state.
+        :param str subscription_id: The OCID of the cloud service subscription to which the protected database is linked.
         :param Mapping[str, str] system_tags: Usage of system tag keys. These predefined keys are scoped to namespaces. Example: `{"orcl-cloud.free-tier-retained": "true"}`. For more information, see [Resource Tags](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/resourcetags.htm)
         :param str time_created: An RFC3339 formatted datetime string that indicates the created time for a protected database. For example: '2020-05-22T21:10:29.600Z'
         :param str time_updated: An RFC3339 formatted datetime string that indicates the last updated time for a protected database. For example: '2020-05-22T21:10:29.600Z'
@@ -451,6 +445,7 @@ class GetProtectedDatabasesProtectedDatabaseCollectionItemResult(dict):
         pulumi.set(__self__, "protection_policy_id", protection_policy_id)
         pulumi.set(__self__, "recovery_service_subnets", recovery_service_subnets)
         pulumi.set(__self__, "state", state)
+        pulumi.set(__self__, "subscription_id", subscription_id)
         pulumi.set(__self__, "system_tags", system_tags)
         pulumi.set(__self__, "time_created", time_created)
         pulumi.set(__self__, "time_updated", time_updated)
@@ -610,6 +605,14 @@ class GetProtectedDatabasesProtectedDatabaseCollectionItemResult(dict):
         """
         return pulumi.get(self, "state")
 
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> str:
+        """
+        The OCID of the cloud service subscription to which the protected database is linked.
+        """
+        return pulumi.get(self, "subscription_id")
+
     @property
     @pulumi.getter(name="systemTags")
     def system_tags(self) -> Mapping[str, str]:
@@ -817,6 +820,7 @@ class GetProtectionPoliciesProtectionPolicyCollectionItemResult(dict):
                  id: str,
                  is_predefined_policy: bool,
                  lifecycle_details: str,
+                 must_enforce_cloud_locality: bool,
                  policy_locked_date_time: str,
                  state: str,
                  system_tags: Mapping[str, str],
@@ -831,6 +835,7 @@ class GetProtectionPoliciesProtectionPolicyCollectionItemResult(dict):
         :param str id: The protection policy OCID.
         :param bool is_predefined_policy: Set to TRUE if the policy is Oracle-defined, and FALSE for a user-defined custom policy. You can modify only the custom policies.
         :param str lifecycle_details: Detailed description about the current lifecycle state of the protection policy. For example, it can be used to provide actionable information for a resource in a Failed state.
+        :param bool must_enforce_cloud_locality: Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned.
         :param str policy_locked_date_time: An RFC3339 formatted datetime string that specifies the exact date and time for the retention lock to take effect and permanently lock the retention period defined in the policy.
         :param str state: A filter to return only resources their lifecycleState matches the given lifecycleState.
         :param Mapping[str, str] system_tags: Usage of system tag keys. These predefined keys are scoped to namespaces. Example: `{"orcl-cloud.free-tier-retained": "true"}`. For more information, see [Resource Tags](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/resourcetags.htm)
@@ -845,6 +850,7 @@ class GetProtectionPoliciesProtectionPolicyCollectionItemResult(dict):
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "is_predefined_policy", is_predefined_policy)
         pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        pulumi.set(__self__, "must_enforce_cloud_locality", must_enforce_cloud_locality)
         pulumi.set(__self__, "policy_locked_date_time", policy_locked_date_time)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "system_tags", system_tags)
@@ -915,6 +921,14 @@ class GetProtectionPoliciesProtectionPolicyCollectionItemResult(dict):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="mustEnforceCloudLocality")
+    def must_enforce_cloud_locality(self) -> bool:
+        """
+        Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned.
+        """
+        return pulumi.get(self, "must_enforce_cloud_locality")
+
     @property
     @pulumi.getter(name="policyLockedDateTime")
     def policy_locked_date_time(self) -> str:

pulumi_oci/recoverymod/protected_database.py

@@ -27,7 +27,8 @@ class ProtectedDatabaseArgs:
                  defined_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  deletion_schedule: Optional[pulumi.Input[str]] = None,
                  freeform_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
-                 is_redo_logs_shipped: Optional[pulumi.Input[bool]] = None):
+                 is_redo_logs_shipped: Optional[pulumi.Input[bool]] = None,
+                 subscription_id: Optional[pulumi.Input[str]] = None):
         """
         The set of arguments for constructing a ProtectedDatabase resource.
         :param pulumi.Input[str] compartment_id: (Updatable) The OCID of the compartment that contains the protected database.
@@ -44,6 +45,11 @@ class ProtectedDatabaseArgs:
                * The alternate schedule is DELETE_AFTER_RETENTION_PERIOD. Specify this option if you want to delete a protected database only after the policy-defined backup retention period expires.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] freeform_tags: (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param pulumi.Input[bool] is_redo_logs_shipped: (Updatable) The value TRUE indicates that the protected database is configured to use Real-time data protection, and redo-data is sent from the protected database to Recovery Service. Real-time data protection substantially reduces the window of potential data loss that exists between successive archived redo log backups.
+        :param pulumi.Input[str] subscription_id: (Updatable) The OCID of the cloud service subscription to which you want to link the protected database.  For example, specify the Microsoft Azure subscription ID if you want to provision the protected database in Azure. 
+               
+               
+               ** IMPORTANT **
+               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         """
         pulumi.set(__self__, "compartment_id", compartment_id)
         pulumi.set(__self__, "db_unique_name", db_unique_name)
@@ -63,6 +69,8 @@ class ProtectedDatabaseArgs:
             pulumi.set(__self__, "freeform_tags", freeform_tags)
         if is_redo_logs_shipped is not None:
             pulumi.set(__self__, "is_redo_logs_shipped", is_redo_logs_shipped)
+        if subscription_id is not None:
+            pulumi.set(__self__, "subscription_id", subscription_id)
 
     @property
     @pulumi.getter(name="compartmentId")
@@ -210,6 +218,22 @@ class ProtectedDatabaseArgs:
     def is_redo_logs_shipped(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_redo_logs_shipped", value)
 
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) The OCID of the cloud service subscription to which you want to link the protected database.  For example, specify the Microsoft Azure subscription ID if you want to provision the protected database in Azure. 
+
+
+        ** IMPORTANT **
+        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        """
+        return pulumi.get(self, "subscription_id")
+
+    @subscription_id.setter
+    def subscription_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "subscription_id", value)
+
 
 @pulumi.input_type
 class _ProtectedDatabaseState:
@@ -233,6 +257,7 @@ class _ProtectedDatabaseState:
                  protection_policy_id: Optional[pulumi.Input[str]] = None,
                  recovery_service_subnets: Optional[pulumi.Input[Sequence[pulumi.Input['ProtectedDatabaseRecoveryServiceSubnetArgs']]]] = None,
                  state: Optional[pulumi.Input[str]] = None,
+                 subscription_id: Optional[pulumi.Input[str]] = None,
                  system_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  time_created: Optional[pulumi.Input[str]] = None,
                  time_updated: Optional[pulumi.Input[str]] = None,
@@ -260,6 +285,11 @@ class _ProtectedDatabaseState:
         :param pulumi.Input[str] protection_policy_id: (Updatable) The OCID of the protection policy associated with the protected database.
         :param pulumi.Input[Sequence[pulumi.Input['ProtectedDatabaseRecoveryServiceSubnetArgs']]] recovery_service_subnets: (Updatable) List of recovery service subnet resources associated with the protected database.
         :param pulumi.Input[str] state: The current state of the Protected Database.
+        :param pulumi.Input[str] subscription_id: (Updatable) The OCID of the cloud service subscription to which you want to link the protected database.  For example, specify the Microsoft Azure subscription ID if you want to provision the protected database in Azure. 
+               
+               
+               ** IMPORTANT **
+               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] system_tags: Usage of system tag keys. These predefined keys are scoped to namespaces. Example: `{"orcl-cloud.free-tier-retained": "true"}`. For more information, see [Resource Tags](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/resourcetags.htm)
         :param pulumi.Input[str] time_created: An RFC3339 formatted datetime string that indicates the created time for a protected database. For example: '2020-05-22T21:10:29.600Z'
         :param pulumi.Input[str] time_updated: An RFC3339 formatted datetime string that indicates the last updated time for a protected database. For example: '2020-05-22T21:10:29.600Z'
@@ -303,6 +333,8 @@ class _ProtectedDatabaseState:
             pulumi.set(__self__, "recovery_service_subnets", recovery_service_subnets)
         if state is not None:
             pulumi.set(__self__, "state", state)
+        if subscription_id is not None:
+            pulumi.set(__self__, "subscription_id", subscription_id)
         if system_tags is not None:
             pulumi.set(__self__, "system_tags", system_tags)
         if time_created is not None:
@@ -542,6 +574,22 @@ class _ProtectedDatabaseState:
     def state(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "state", value)
 
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Updatable) The OCID of the cloud service subscription to which you want to link the protected database.  For example, specify the Microsoft Azure subscription ID if you want to provision the protected database in Azure. 
+
+
+        ** IMPORTANT **
+        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        """
+        return pulumi.get(self, "subscription_id")
+
+    @subscription_id.setter
+    def subscription_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "subscription_id", value)
+
     @property
     @pulumi.getter(name="systemTags")
     def system_tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
@@ -608,6 +656,7 @@ class ProtectedDatabase(pulumi.CustomResource):
                  password: Optional[pulumi.Input[str]] = None,
                  protection_policy_id: Optional[pulumi.Input[str]] = None,
                  recovery_service_subnets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProtectedDatabaseRecoveryServiceSubnetArgs', 'ProtectedDatabaseRecoveryServiceSubnetArgsDict']]]]] = None,
+                 subscription_id: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         """
         This resource provides the Protected Database resource in Oracle Cloud Infrastructure Recovery service.
@@ -638,7 +687,8 @@ class ProtectedDatabase(pulumi.CustomResource):
             freeform_tags={
                 "bar-key": "value",
             },
-            is_redo_logs_shipped=protected_database_is_redo_logs_shipped)
+            is_redo_logs_shipped=protected_database_is_redo_logs_shipped,
+            subscription_id=test_subscription["id"])
         ```
 
         ## Import
@@ -665,6 +715,11 @@ class ProtectedDatabase(pulumi.CustomResource):
         :param pulumi.Input[str] password: (Updatable) Password credential which can be used to connect to Protected Database. It must contain at least 2 uppercase, 2 lowercase, 2 numeric and 2 special characters. The special characters must be underscore (_), number sign (https://docs.cloud.oracle.com/iaas/api/#) or hyphen (-). The password must not contain the username "admin", regardless of casing.
         :param pulumi.Input[str] protection_policy_id: (Updatable) The OCID of the protection policy associated with the protected database.
         :param pulumi.Input[Sequence[pulumi.Input[Union['ProtectedDatabaseRecoveryServiceSubnetArgs', 'ProtectedDatabaseRecoveryServiceSubnetArgsDict']]]] recovery_service_subnets: (Updatable) List of recovery service subnet resources associated with the protected database.
+        :param pulumi.Input[str] subscription_id: (Updatable) The OCID of the cloud service subscription to which you want to link the protected database.  For example, specify the Microsoft Azure subscription ID if you want to provision the protected database in Azure. 
+               
+               
+               ** IMPORTANT **
+               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         """
         ...
     @overload
@@ -701,7 +756,8 @@ class ProtectedDatabase(pulumi.CustomResource):
             freeform_tags={
                 "bar-key": "value",
             },
-            is_redo_logs_shipped=protected_database_is_redo_logs_shipped)
+            is_redo_logs_shipped=protected_database_is_redo_logs_shipped,
+            subscription_id=test_subscription["id"])
         ```
 
         ## Import
@@ -739,6 +795,7 @@ class ProtectedDatabase(pulumi.CustomResource):
                  password: Optional[pulumi.Input[str]] = None,
                  protection_policy_id: Optional[pulumi.Input[str]] = None,
                  recovery_service_subnets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProtectedDatabaseRecoveryServiceSubnetArgs', 'ProtectedDatabaseRecoveryServiceSubnetArgsDict']]]]] = None,
+                 subscription_id: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
         if not isinstance(opts, pulumi.ResourceOptions):
@@ -772,6 +829,7 @@ class ProtectedDatabase(pulumi.CustomResource):
             if recovery_service_subnets is None and not opts.urn:
                 raise TypeError("Missing required property 'recovery_service_subnets'")
             __props__.__dict__["recovery_service_subnets"] = recovery_service_subnets
+            __props__.__dict__["subscription_id"] = subscription_id
             __props__.__dict__["health"] = None
             __props__.__dict__["health_details"] = None
             __props__.__dict__["is_read_only_resource"] = None
@@ -814,6 +872,7 @@ class ProtectedDatabase(pulumi.CustomResource):
             protection_policy_id: Optional[pulumi.Input[str]] = None,
             recovery_service_subnets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProtectedDatabaseRecoveryServiceSubnetArgs', 'ProtectedDatabaseRecoveryServiceSubnetArgsDict']]]]] = None,
             state: Optional[pulumi.Input[str]] = None,
+            subscription_id: Optional[pulumi.Input[str]] = None,
             system_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             time_created: Optional[pulumi.Input[str]] = None,
             time_updated: Optional[pulumi.Input[str]] = None,
@@ -846,6 +905,11 @@ class ProtectedDatabase(pulumi.CustomResource):
         :param pulumi.Input[str] protection_policy_id: (Updatable) The OCID of the protection policy associated with the protected database.
         :param pulumi.Input[Sequence[pulumi.Input[Union['ProtectedDatabaseRecoveryServiceSubnetArgs', 'ProtectedDatabaseRecoveryServiceSubnetArgsDict']]]] recovery_service_subnets: (Updatable) List of recovery service subnet resources associated with the protected database.
         :param pulumi.Input[str] state: The current state of the Protected Database.
+        :param pulumi.Input[str] subscription_id: (Updatable) The OCID of the cloud service subscription to which you want to link the protected database.  For example, specify the Microsoft Azure subscription ID if you want to provision the protected database in Azure. 
+               
+               
+               ** IMPORTANT **
+               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] system_tags: Usage of system tag keys. These predefined keys are scoped to namespaces. Example: `{"orcl-cloud.free-tier-retained": "true"}`. For more information, see [Resource Tags](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/resourcetags.htm)
         :param pulumi.Input[str] time_created: An RFC3339 formatted datetime string that indicates the created time for a protected database. For example: '2020-05-22T21:10:29.600Z'
         :param pulumi.Input[str] time_updated: An RFC3339 formatted datetime string that indicates the last updated time for a protected database. For example: '2020-05-22T21:10:29.600Z'
@@ -874,6 +938,7 @@ class ProtectedDatabase(pulumi.CustomResource):
         __props__.__dict__["protection_policy_id"] = protection_policy_id
         __props__.__dict__["recovery_service_subnets"] = recovery_service_subnets
         __props__.__dict__["state"] = state
+        __props__.__dict__["subscription_id"] = subscription_id
         __props__.__dict__["system_tags"] = system_tags
         __props__.__dict__["time_created"] = time_created
         __props__.__dict__["time_updated"] = time_updated
@@ -1034,6 +1099,18 @@ class ProtectedDatabase(pulumi.CustomResource):
         """
         return pulumi.get(self, "state")
 
+    @property
+    @pulumi.getter(name="subscriptionId")
+    def subscription_id(self) -> pulumi.Output[str]:
+        """
+        (Updatable) The OCID of the cloud service subscription to which you want to link the protected database.  For example, specify the Microsoft Azure subscription ID if you want to provision the protected database in Azure. 
+
+
+        ** IMPORTANT **
+        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        """
+        return pulumi.get(self, "subscription_id")
+
     @property
     @pulumi.getter(name="systemTags")
     def system_tags(self) -> pulumi.Output[Mapping[str, str]]:

pulumi_oci/recoverymod/protection_policy.py

@@ -19,6 +19,7 @@ class ProtectionPolicyArgs:
                  display_name: pulumi.Input[str],
                  defined_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  freeform_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 must_enforce_cloud_locality: Optional[pulumi.Input[bool]] = None,
                  policy_locked_date_time: Optional[pulumi.Input[str]] = None):
         """
         The set of arguments for constructing a ProtectionPolicy resource.
@@ -27,6 +28,7 @@ class ProtectionPolicyArgs:
         :param pulumi.Input[str] display_name: (Updatable) A user provided name for the protection policy. The 'displayName' does not have to be unique, and it can be modified. Avoid entering confidential information.
         :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"}`. For more information, see [Resource Tags](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/resourcetags.htm)
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] freeform_tags: (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param pulumi.Input[bool] must_enforce_cloud_locality: Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned. This parameter is applicable if your Oracle Database runs in a different cloud service environment, such as Microsoft Azure. If you set the mustEnforceCloudLocality parameter to TRUE, then Recovery Service stores the database backups locally in the same cloud service environment where the database resides. For example, if your Oracle Database is provisioned on Microsoft Azure, then Recovery Service stores the database backups in Azure. Note: You cannot change the mustEnforceCloudLocality setting for a protection policy after you create it.
         :param pulumi.Input[str] policy_locked_date_time: (Updatable) An RFC3339 formatted datetime string that specifies the exact date and time for the retention lock to take effect and permanently lock the retention period defined in the policy.
                * The retention lock feature controls whether Recovery Service strictly preserves backups for the duration defined in a policy. Retention lock is useful to enforce recovery window compliance and to prevent unintentional modifications to protected database backups.
                * Recovery Service enforces a 14-day delay before the retention lock set for a policy can take effect. Therefore, you must set policyLockedDateTime  to a date that occurs 14 days after the current date.
@@ -46,6 +48,8 @@ class ProtectionPolicyArgs:
             pulumi.set(__self__, "defined_tags", defined_tags)
         if freeform_tags is not None:
             pulumi.set(__self__, "freeform_tags", freeform_tags)
+        if must_enforce_cloud_locality is not None:
+            pulumi.set(__self__, "must_enforce_cloud_locality", must_enforce_cloud_locality)
         if policy_locked_date_time is not None:
             pulumi.set(__self__, "policy_locked_date_time", policy_locked_date_time)
 
@@ -109,6 +113,18 @@ class ProtectionPolicyArgs:
     def freeform_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "freeform_tags", value)
 
+    @property
+    @pulumi.getter(name="mustEnforceCloudLocality")
+    def must_enforce_cloud_locality(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned. This parameter is applicable if your Oracle Database runs in a different cloud service environment, such as Microsoft Azure. If you set the mustEnforceCloudLocality parameter to TRUE, then Recovery Service stores the database backups locally in the same cloud service environment where the database resides. For example, if your Oracle Database is provisioned on Microsoft Azure, then Recovery Service stores the database backups in Azure. Note: You cannot change the mustEnforceCloudLocality setting for a protection policy after you create it.
+        """
+        return pulumi.get(self, "must_enforce_cloud_locality")
+
+    @must_enforce_cloud_locality.setter
+    def must_enforce_cloud_locality(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "must_enforce_cloud_locality", value)
+
     @property
     @pulumi.getter(name="policyLockedDateTime")
     def policy_locked_date_time(self) -> Optional[pulumi.Input[str]]:
@@ -142,6 +158,7 @@ class _ProtectionPolicyState:
                  freeform_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  is_predefined_policy: Optional[pulumi.Input[bool]] = None,
                  lifecycle_details: Optional[pulumi.Input[str]] = None,
+                 must_enforce_cloud_locality: Optional[pulumi.Input[bool]] = None,
                  policy_locked_date_time: Optional[pulumi.Input[str]] = None,
                  state: Optional[pulumi.Input[str]] = None,
                  system_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -156,6 +173,7 @@ class _ProtectionPolicyState:
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] freeform_tags: (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param pulumi.Input[bool] is_predefined_policy: Set to TRUE if the policy is Oracle-defined, and FALSE for a user-defined custom policy. You can modify only the custom policies.
         :param pulumi.Input[str] lifecycle_details: Detailed description about the current lifecycle state of the protection policy. For example, it can be used to provide actionable information for a resource in a Failed state.
+        :param pulumi.Input[bool] must_enforce_cloud_locality: Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned. This parameter is applicable if your Oracle Database runs in a different cloud service environment, such as Microsoft Azure. If you set the mustEnforceCloudLocality parameter to TRUE, then Recovery Service stores the database backups locally in the same cloud service environment where the database resides. For example, if your Oracle Database is provisioned on Microsoft Azure, then Recovery Service stores the database backups in Azure. Note: You cannot change the mustEnforceCloudLocality setting for a protection policy after you create it.
         :param pulumi.Input[str] policy_locked_date_time: (Updatable) An RFC3339 formatted datetime string that specifies the exact date and time for the retention lock to take effect and permanently lock the retention period defined in the policy.
                * The retention lock feature controls whether Recovery Service strictly preserves backups for the duration defined in a policy. Retention lock is useful to enforce recovery window compliance and to prevent unintentional modifications to protected database backups.
                * Recovery Service enforces a 14-day delay before the retention lock set for a policy can take effect. Therefore, you must set policyLockedDateTime  to a date that occurs 14 days after the current date.
@@ -186,6 +204,8 @@ class _ProtectionPolicyState:
             pulumi.set(__self__, "is_predefined_policy", is_predefined_policy)
         if lifecycle_details is not None:
             pulumi.set(__self__, "lifecycle_details", lifecycle_details)
+        if must_enforce_cloud_locality is not None:
+            pulumi.set(__self__, "must_enforce_cloud_locality", must_enforce_cloud_locality)
         if policy_locked_date_time is not None:
             pulumi.set(__self__, "policy_locked_date_time", policy_locked_date_time)
         if state is not None:
@@ -281,6 +301,18 @@ class _ProtectionPolicyState:
     def lifecycle_details(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "lifecycle_details", value)
 
+    @property
+    @pulumi.getter(name="mustEnforceCloudLocality")
+    def must_enforce_cloud_locality(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned. This parameter is applicable if your Oracle Database runs in a different cloud service environment, such as Microsoft Azure. If you set the mustEnforceCloudLocality parameter to TRUE, then Recovery Service stores the database backups locally in the same cloud service environment where the database resides. For example, if your Oracle Database is provisioned on Microsoft Azure, then Recovery Service stores the database backups in Azure. Note: You cannot change the mustEnforceCloudLocality setting for a protection policy after you create it.
+        """
+        return pulumi.get(self, "must_enforce_cloud_locality")
+
+    @must_enforce_cloud_locality.setter
+    def must_enforce_cloud_locality(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "must_enforce_cloud_locality", value)
+
     @property
     @pulumi.getter(name="policyLockedDateTime")
     def policy_locked_date_time(self) -> Optional[pulumi.Input[str]]:
@@ -362,6 +394,7 @@ class ProtectionPolicy(pulumi.CustomResource):
                  defined_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  display_name: Optional[pulumi.Input[str]] = None,
                  freeform_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 must_enforce_cloud_locality: Optional[pulumi.Input[bool]] = None,
                  policy_locked_date_time: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         """
@@ -385,6 +418,7 @@ class ProtectionPolicy(pulumi.CustomResource):
             freeform_tags={
                 "bar-key": "value",
             },
+            must_enforce_cloud_locality=protection_policy_must_enforce_cloud_locality,
             policy_locked_date_time=protection_policy_policy_locked_date_time)
         ```
 
@@ -403,6 +437,7 @@ class ProtectionPolicy(pulumi.CustomResource):
         :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"}`. For more information, see [Resource Tags](https://docs.oracle.com/en-us/iaas/Content/General/Concepts/resourcetags.htm)
         :param pulumi.Input[str] display_name: (Updatable) A user provided name for the protection policy. The 'displayName' does not have to be unique, and it can be modified. Avoid entering confidential information.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] freeform_tags: (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
+        :param pulumi.Input[bool] must_enforce_cloud_locality: Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned. This parameter is applicable if your Oracle Database runs in a different cloud service environment, such as Microsoft Azure. If you set the mustEnforceCloudLocality parameter to TRUE, then Recovery Service stores the database backups locally in the same cloud service environment where the database resides. For example, if your Oracle Database is provisioned on Microsoft Azure, then Recovery Service stores the database backups in Azure. Note: You cannot change the mustEnforceCloudLocality setting for a protection policy after you create it.
         :param pulumi.Input[str] policy_locked_date_time: (Updatable) An RFC3339 formatted datetime string that specifies the exact date and time for the retention lock to take effect and permanently lock the retention period defined in the policy.
                * The retention lock feature controls whether Recovery Service strictly preserves backups for the duration defined in a policy. Retention lock is useful to enforce recovery window compliance and to prevent unintentional modifications to protected database backups.
                * Recovery Service enforces a 14-day delay before the retention lock set for a policy can take effect. Therefore, you must set policyLockedDateTime  to a date that occurs 14 days after the current date.
@@ -442,6 +477,7 @@ class ProtectionPolicy(pulumi.CustomResource):
             freeform_tags={
                 "bar-key": "value",
             },
+            must_enforce_cloud_locality=protection_policy_must_enforce_cloud_locality,
             policy_locked_date_time=protection_policy_policy_locked_date_time)
         ```
 
@@ -473,6 +509,7 @@ class ProtectionPolicy(pulumi.CustomResource):
                  defined_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  display_name: Optional[pulumi.Input[str]] = None,
                  freeform_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 must_enforce_cloud_locality: Optional[pulumi.Input[bool]] = None,
                  policy_locked_date_time: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -494,6 +531,7 @@ class ProtectionPolicy(pulumi.CustomResource):
                 raise TypeError("Missing required property 'display_name'")
             __props__.__dict__["display_name"] = display_name
             __props__.__dict__["freeform_tags"] = freeform_tags
+            __props__.__dict__["must_enforce_cloud_locality"] = must_enforce_cloud_locality
             __props__.__dict__["policy_locked_date_time"] = policy_locked_date_time
             __props__.__dict__["is_predefined_policy"] = None
             __props__.__dict__["lifecycle_details"] = None
@@ -518,6 +556,7 @@ class ProtectionPolicy(pulumi.CustomResource):
             freeform_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             is_predefined_policy: Optional[pulumi.Input[bool]] = None,
             lifecycle_details: Optional[pulumi.Input[str]] = None,
+            must_enforce_cloud_locality: Optional[pulumi.Input[bool]] = None,
             policy_locked_date_time: Optional[pulumi.Input[str]] = None,
             state: Optional[pulumi.Input[str]] = None,
             system_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -537,6 +576,7 @@ class ProtectionPolicy(pulumi.CustomResource):
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] freeform_tags: (Updatable) Simple key-value pair that is applied without any predefined name, type or scope. Exists for cross-compatibility only. Example: `{"bar-key": "value"}`
         :param pulumi.Input[bool] is_predefined_policy: Set to TRUE if the policy is Oracle-defined, and FALSE for a user-defined custom policy. You can modify only the custom policies.
         :param pulumi.Input[str] lifecycle_details: Detailed description about the current lifecycle state of the protection policy. For example, it can be used to provide actionable information for a resource in a Failed state.
+        :param pulumi.Input[bool] must_enforce_cloud_locality: Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned. This parameter is applicable if your Oracle Database runs in a different cloud service environment, such as Microsoft Azure. If you set the mustEnforceCloudLocality parameter to TRUE, then Recovery Service stores the database backups locally in the same cloud service environment where the database resides. For example, if your Oracle Database is provisioned on Microsoft Azure, then Recovery Service stores the database backups in Azure. Note: You cannot change the mustEnforceCloudLocality setting for a protection policy after you create it.
         :param pulumi.Input[str] policy_locked_date_time: (Updatable) An RFC3339 formatted datetime string that specifies the exact date and time for the retention lock to take effect and permanently lock the retention period defined in the policy.
                * The retention lock feature controls whether Recovery Service strictly preserves backups for the duration defined in a policy. Retention lock is useful to enforce recovery window compliance and to prevent unintentional modifications to protected database backups.
                * Recovery Service enforces a 14-day delay before the retention lock set for a policy can take effect. Therefore, you must set policyLockedDateTime  to a date that occurs 14 days after the current date.
@@ -564,6 +604,7 @@ class ProtectionPolicy(pulumi.CustomResource):
         __props__.__dict__["freeform_tags"] = freeform_tags
         __props__.__dict__["is_predefined_policy"] = is_predefined_policy
         __props__.__dict__["lifecycle_details"] = lifecycle_details
+        __props__.__dict__["must_enforce_cloud_locality"] = must_enforce_cloud_locality
         __props__.__dict__["policy_locked_date_time"] = policy_locked_date_time
         __props__.__dict__["state"] = state
         __props__.__dict__["system_tags"] = system_tags
@@ -627,6 +668,14 @@ class ProtectionPolicy(pulumi.CustomResource):
         """
         return pulumi.get(self, "lifecycle_details")
 
+    @property
+    @pulumi.getter(name="mustEnforceCloudLocality")
+    def must_enforce_cloud_locality(self) -> pulumi.Output[bool]:
+        """
+        Indicates whether the protection policy enforces Recovery Service to retain backups in the same cloud service environment where your Oracle Database is provisioned. This parameter is applicable if your Oracle Database runs in a different cloud service environment, such as Microsoft Azure. If you set the mustEnforceCloudLocality parameter to TRUE, then Recovery Service stores the database backups locally in the same cloud service environment where the database resides. For example, if your Oracle Database is provisioned on Microsoft Azure, then Recovery Service stores the database backups in Azure. Note: You cannot change the mustEnforceCloudLocality setting for a protection policy after you create it.
+        """
+        return pulumi.get(self, "must_enforce_cloud_locality")
+
     @property
     @pulumi.getter(name="policyLockedDateTime")
     def policy_locked_date_time(self) -> pulumi.Output[str]: