Add support for instance import / export / failover (via synth). (#7423)

Author: yoshi-automation

redis/google/cloud/redis_v1/gapic/cloud_redis_client.py

@@ -642,3 +642,265 @@ def delete_instance(
             empty_pb2.Empty,
             metadata_type=cloud_redis_pb2.OperationMetadata,
         )
+
+    def import_instance(
+        self,
+        name,
+        input_config,
+        retry=google.api_core.gapic_v1.method.DEFAULT,
+        timeout=google.api_core.gapic_v1.method.DEFAULT,
+        metadata=None,
+    ):
+        """
+        Import a Redis RDB snapshot file from GCS into a Redis instance.
+
+        Redis may stop serving during this operation. Instance state will be
+        IMPORTING for entire operation. When complete, the instance will contain
+        only data from the imported file.
+
+        The returned operation is automatically deleted after a few hours, so
+        there is no need to call DeleteOperation.
+
+        Example:
+            >>> from google.cloud import redis_v1
+            >>>
+            >>> client = redis_v1.CloudRedisClient()
+            >>>
+            >>> name = client.instance_path('[PROJECT]', '[LOCATION]', '[INSTANCE]')
+            >>>
+            >>> # TODO: Initialize `input_config`:
+            >>> input_config = {}
+            >>>
+            >>> response = client.import_instance(name, input_config)
+            >>>
+            >>> def callback(operation_future):
+            ...     # Handle result.
+            ...     result = operation_future.result()
+            >>>
+            >>> response.add_done_callback(callback)
+            >>>
+            >>> # Handle metadata.
+            >>> metadata = response.metadata()
+
+        Args:
+            name (str): Required. Redis instance resource name using the form:
+                ``projects/{project_id}/locations/{location_id}/instances/{instance_id}``
+                where ``location_id`` refers to a GCP region
+            input_config (Union[dict, ~google.cloud.redis_v1.types.InputConfig]): Required. Specify data to be imported.
+
+                If a dict is provided, it must be of the same form as the protobuf
+                message :class:`~google.cloud.redis_v1.types.InputConfig`
+            retry (Optional[google.api_core.retry.Retry]):  A retry object used
+                to retry requests. If ``None`` is specified, requests will not
+                be retried.
+            timeout (Optional[float]): The amount of time, in seconds, to wait
+                for the request to complete. Note that if ``retry`` is
+                specified, the timeout applies to each individual attempt.
+            metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
+                that is provided to the method.
+
+        Returns:
+            A :class:`~google.cloud.redis_v1.types._OperationFuture` instance.
+
+        Raises:
+            google.api_core.exceptions.GoogleAPICallError: If the request
+                    failed for any reason.
+            google.api_core.exceptions.RetryError: If the request failed due
+                    to a retryable error and retry attempts failed.
+            ValueError: If the parameters are invalid.
+        """
+        # Wrap the transport method to add retry and timeout logic.
+        if "import_instance" not in self._inner_api_calls:
+            self._inner_api_calls[
+                "import_instance"
+            ] = google.api_core.gapic_v1.method.wrap_method(
+                self.transport.import_instance,
+                default_retry=self._method_configs["ImportInstance"].retry,
+                default_timeout=self._method_configs["ImportInstance"].timeout,
+                client_info=self._client_info,
+            )
+
+        request = cloud_redis_pb2.ImportInstanceRequest(
+            name=name, input_config=input_config
+        )
+        operation = self._inner_api_calls["import_instance"](
+            request, retry=retry, timeout=timeout, metadata=metadata
+        )
+        return google.api_core.operation.from_gapic(
+            operation,
+            self.transport._operations_client,
+            cloud_redis_pb2.Instance,
+            metadata_type=cloud_redis_pb2.OperationMetadata,
+        )
+
+    def export_instance(
+        self,
+        name,
+        output_config,
+        retry=google.api_core.gapic_v1.method.DEFAULT,
+        timeout=google.api_core.gapic_v1.method.DEFAULT,
+        metadata=None,
+    ):
+        """
+        Export Redis instance data into a Redis RDB format file in GCS.
+
+        Redis will continue serving during this operation.
+
+        The returned operation is automatically deleted after a few hours, so
+        there is no need to call DeleteOperation.
+
+        Example:
+            >>> from google.cloud import redis_v1
+            >>>
+            >>> client = redis_v1.CloudRedisClient()
+            >>>
+            >>> name = client.instance_path('[PROJECT]', '[LOCATION]', '[INSTANCE]')
+            >>>
+            >>> # TODO: Initialize `output_config`:
+            >>> output_config = {}
+            >>>
+            >>> response = client.export_instance(name, output_config)
+            >>>
+            >>> def callback(operation_future):
+            ...     # Handle result.
+            ...     result = operation_future.result()
+            >>>
+            >>> response.add_done_callback(callback)
+            >>>
+            >>> # Handle metadata.
+            >>> metadata = response.metadata()
+
+        Args:
+            name (str): Required. Redis instance resource name using the form:
+                ``projects/{project_id}/locations/{location_id}/instances/{instance_id}``
+                where ``location_id`` refers to a GCP region
+            output_config (Union[dict, ~google.cloud.redis_v1.types.OutputConfig]): Required. Specify data to be exported.
+
+                If a dict is provided, it must be of the same form as the protobuf
+                message :class:`~google.cloud.redis_v1.types.OutputConfig`
+            retry (Optional[google.api_core.retry.Retry]):  A retry object used
+                to retry requests. If ``None`` is specified, requests will not
+                be retried.
+            timeout (Optional[float]): The amount of time, in seconds, to wait
+                for the request to complete. Note that if ``retry`` is
+                specified, the timeout applies to each individual attempt.
+            metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
+                that is provided to the method.
+
+        Returns:
+            A :class:`~google.cloud.redis_v1.types._OperationFuture` instance.
+
+        Raises:
+            google.api_core.exceptions.GoogleAPICallError: If the request
+                    failed for any reason.
+            google.api_core.exceptions.RetryError: If the request failed due
+                    to a retryable error and retry attempts failed.
+            ValueError: If the parameters are invalid.
+        """
+        # Wrap the transport method to add retry and timeout logic.
+        if "export_instance" not in self._inner_api_calls:
+            self._inner_api_calls[
+                "export_instance"
+            ] = google.api_core.gapic_v1.method.wrap_method(
+                self.transport.export_instance,
+                default_retry=self._method_configs["ExportInstance"].retry,
+                default_timeout=self._method_configs["ExportInstance"].timeout,
+                client_info=self._client_info,
+            )
+
+        request = cloud_redis_pb2.ExportInstanceRequest(
+            name=name, output_config=output_config
+        )
+        operation = self._inner_api_calls["export_instance"](
+            request, retry=retry, timeout=timeout, metadata=metadata
+        )
+        return google.api_core.operation.from_gapic(
+            operation,
+            self.transport._operations_client,
+            cloud_redis_pb2.Instance,
+            metadata_type=cloud_redis_pb2.OperationMetadata,
+        )
+
+    def failover_instance(
+        self,
+        name,
+        data_protection_mode,
+        retry=google.api_core.gapic_v1.method.DEFAULT,
+        timeout=google.api_core.gapic_v1.method.DEFAULT,
+        metadata=None,
+    ):
+        """
+        Failover the master role to current replica node against a specific
+        STANDARD tier redis instance.
+
+        Example:
+            >>> from google.cloud import redis_v1
+            >>> from google.cloud.redis_v1 import enums
+            >>>
+            >>> client = redis_v1.CloudRedisClient()
+            >>>
+            >>> name = client.instance_path('[PROJECT]', '[LOCATION]', '[INSTANCE]')
+            >>>
+            >>> # TODO: Initialize `data_protection_mode`:
+            >>> data_protection_mode = enums.FailoverInstanceRequest.DataProtectionMode.DATA_PROTECTION_MODE_UNSPECIFIED
+            >>>
+            >>> response = client.failover_instance(name, data_protection_mode)
+            >>>
+            >>> def callback(operation_future):
+            ...     # Handle result.
+            ...     result = operation_future.result()
+            >>>
+            >>> response.add_done_callback(callback)
+            >>>
+            >>> # Handle metadata.
+            >>> metadata = response.metadata()
+
+        Args:
+            name (str): Required. Redis instance resource name using the form:
+                ``projects/{project_id}/locations/{location_id}/instances/{instance_id}``
+                where ``location_id`` refers to a GCP region
+            data_protection_mode (~google.cloud.redis_v1.types.DataProtectionMode): Optional. Available data protection modes that the user can choose. If
+                it's unspecified, data protection mode will be LIMITED\_DATA\_LOSS by
+                default.
+            retry (Optional[google.api_core.retry.Retry]):  A retry object used
+                to retry requests. If ``None`` is specified, requests will not
+                be retried.
+            timeout (Optional[float]): The amount of time, in seconds, to wait
+                for the request to complete. Note that if ``retry`` is
+                specified, the timeout applies to each individual attempt.
+            metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
+                that is provided to the method.
+
+        Returns:
+            A :class:`~google.cloud.redis_v1.types._OperationFuture` instance.
+
+        Raises:
+            google.api_core.exceptions.GoogleAPICallError: If the request
+                    failed for any reason.
+            google.api_core.exceptions.RetryError: If the request failed due
+                    to a retryable error and retry attempts failed.
+            ValueError: If the parameters are invalid.
+        """
+        # Wrap the transport method to add retry and timeout logic.
+        if "failover_instance" not in self._inner_api_calls:
+            self._inner_api_calls[
+                "failover_instance"
+            ] = google.api_core.gapic_v1.method.wrap_method(
+                self.transport.failover_instance,
+                default_retry=self._method_configs["FailoverInstance"].retry,
+                default_timeout=self._method_configs["FailoverInstance"].timeout,
+                client_info=self._client_info,
+            )
+
+        request = cloud_redis_pb2.FailoverInstanceRequest(
+            name=name, data_protection_mode=data_protection_mode
+        )
+        operation = self._inner_api_calls["failover_instance"](
+            request, retry=retry, timeout=timeout, metadata=metadata
+        )
+        return google.api_core.operation.from_gapic(
+            operation,
+            self.transport._operations_client,
+            cloud_redis_pb2.Instance,
+            metadata_type=cloud_redis_pb2.OperationMetadata,
+        )

redis/google/cloud/redis_v1/gapic/cloud_redis_client_config.py

@@ -42,6 +42,21 @@
                     "retry_codes_name": "non_idempotent",
                     "retry_params_name": "default",
                 },
+                "ImportInstance": {
+                    "timeout_millis": 60000,
+                    "retry_codes_name": "non_idempotent",
+                    "retry_params_name": "default",
+                },
+                "ExportInstance": {
+                    "timeout_millis": 60000,
+                    "retry_codes_name": "non_idempotent",
+                    "retry_params_name": "default",
+                },
+                "FailoverInstance": {
+                    "timeout_millis": 60000,
+                    "retry_codes_name": "non_idempotent",
+                    "retry_params_name": "default",
+                },
             },
         }
     }

redis/google/cloud/redis_v1/gapic/enums.py

@@ -18,6 +18,23 @@
 import enum
 
 
+class FailoverInstanceRequest(object):
+    class DataProtectionMode(enum.IntEnum):
+        """
+        Attributes:
+          DATA_PROTECTION_MODE_UNSPECIFIED (int)
+          LIMITED_DATA_LOSS (int): Instance failover will be protected with data loss control. More
+          specifically, the failover will only be performed if the current
+          replication offset diff between master and replica is under a certain
+          threshold.
+          FORCE_DATA_LOSS (int): Instance failover will be performed without data loss control.
+        """
+
+        DATA_PROTECTION_MODE_UNSPECIFIED = 0
+        LIMITED_DATA_LOSS = 1
+        FORCE_DATA_LOSS = 2
+
+
 class Instance(object):
     class State(enum.IntEnum):
         """
@@ -31,9 +48,10 @@ class State(enum.IntEnum):
           may cause the instance to become unusable while the update is in
           progress.
           DELETING (int): Redis instance is being deleted.
-          REPAIRING (int): Redis instance is being repaired and may be unusable. Details can be
-          found in the ``status_message`` field.
+          REPAIRING (int): Redis instance is being repaired and may be unusable.
           MAINTENANCE (int): Maintenance is being performed on this Redis instance.
+          IMPORTING (int): Redis instance is importing data (availability may be affected).
+          FAILING_OVER (int): Redis instance is failing over (availability may be affected).
         """
 
         STATE_UNSPECIFIED = 0
@@ -43,6 +61,8 @@ class State(enum.IntEnum):
         DELETING = 4
         REPAIRING = 5
         MAINTENANCE = 6
+        IMPORTING = 8
+        FAILING_OVER = 9
 
     class Tier(enum.IntEnum):
         """

redis/google/cloud/redis_v1/gapic/transports/cloud_redis_grpc_transport.py

@@ -189,3 +189,55 @@ def delete_instance(self):
                 deserialized response object.
         """
         return self._stubs["cloud_redis_stub"].DeleteInstance
+
+    @property
+    def import_instance(self):
+        """Return the gRPC stub for :meth:`CloudRedisClient.import_instance`.
+
+        Import a Redis RDB snapshot file from GCS into a Redis instance.
+
+        Redis may stop serving during this operation. Instance state will be
+        IMPORTING for entire operation. When complete, the instance will contain
+        only data from the imported file.
+
+        The returned operation is automatically deleted after a few hours, so
+        there is no need to call DeleteOperation.
+
+        Returns:
+            Callable: A callable which accepts the appropriate
+                deserialized request object and returns a
+                deserialized response object.
+        """
+        return self._stubs["cloud_redis_stub"].ImportInstance
+
+    @property
+    def export_instance(self):
+        """Return the gRPC stub for :meth:`CloudRedisClient.export_instance`.
+
+        Export Redis instance data into a Redis RDB format file in GCS.
+
+        Redis will continue serving during this operation.
+
+        The returned operation is automatically deleted after a few hours, so
+        there is no need to call DeleteOperation.
+
+        Returns:
+            Callable: A callable which accepts the appropriate
+                deserialized request object and returns a
+                deserialized response object.
+        """
+        return self._stubs["cloud_redis_stub"].ExportInstance
+
+    @property
+    def failover_instance(self):
+        """Return the gRPC stub for :meth:`CloudRedisClient.failover_instance`.
+
+        Failover the master role to current replica node against a specific
+        STANDARD tier redis instance.
+
+        Returns:
+            Callable: A callable which accepts the appropriate
+                deserialized request object and returns a
+                deserialized response object.
+        """
+        return self._stubs["cloud_redis_stub"].FailoverInstance