diff --git a/google/cloud/gke_backup_v1/gapic_metadata.json b/google/cloud/gke_backup_v1/gapic_metadata.json index 1ab6f6e..a25bf83 100644 --- a/google/cloud/gke_backup_v1/gapic_metadata.json +++ b/google/cloud/gke_backup_v1/gapic_metadata.json @@ -256,6 +256,131 @@ ] } } + }, + "rest": { + "libraryClient": "BackupForGKEClient", + "rpcs": { + "CreateBackup": { + "methods": [ + "create_backup" + ] + }, + "CreateBackupPlan": { + "methods": [ + "create_backup_plan" + ] + }, + "CreateRestore": { + "methods": [ + "create_restore" + ] + }, + "CreateRestorePlan": { + "methods": [ + "create_restore_plan" + ] + }, + "DeleteBackup": { + "methods": [ + "delete_backup" + ] + }, + "DeleteBackupPlan": { + "methods": [ + "delete_backup_plan" + ] + }, + "DeleteRestore": { + "methods": [ + "delete_restore" + ] + }, + "DeleteRestorePlan": { + "methods": [ + "delete_restore_plan" + ] + }, + "GetBackup": { + "methods": [ + "get_backup" + ] + }, + "GetBackupPlan": { + "methods": [ + "get_backup_plan" + ] + }, + "GetRestore": { + "methods": [ + "get_restore" + ] + }, + "GetRestorePlan": { + "methods": [ + "get_restore_plan" + ] + }, + "GetVolumeBackup": { + "methods": [ + "get_volume_backup" + ] + }, + "GetVolumeRestore": { + "methods": [ + "get_volume_restore" + ] + }, + "ListBackupPlans": { + "methods": [ + "list_backup_plans" + ] + }, + "ListBackups": { + "methods": [ + "list_backups" + ] + }, + "ListRestorePlans": { + "methods": [ + "list_restore_plans" + ] + }, + "ListRestores": { + "methods": [ + "list_restores" + ] + }, + "ListVolumeBackups": { + "methods": [ + "list_volume_backups" + ] + }, + "ListVolumeRestores": { + "methods": [ + "list_volume_restores" + ] + }, + "UpdateBackup": { + "methods": [ + "update_backup" + ] + }, + "UpdateBackupPlan": { + "methods": [ + "update_backup_plan" + ] + }, + "UpdateRestore": { + "methods": [ + "update_restore" + ] + }, + "UpdateRestorePlan": { + "methods": [ + "update_restore_plan" + ] + } + } } } } diff --git a/google/cloud/gke_backup_v1/services/backup_for_gke/client.py b/google/cloud/gke_backup_v1/services/backup_for_gke/client.py index fb4cf06..f5b3546 100644 --- a/google/cloud/gke_backup_v1/services/backup_for_gke/client.py +++ b/google/cloud/gke_backup_v1/services/backup_for_gke/client.py @@ -54,6 +54,7 @@ from .transports.base import BackupForGKETransport, DEFAULT_CLIENT_INFO from .transports.grpc import BackupForGKEGrpcTransport from .transports.grpc_asyncio import BackupForGKEGrpcAsyncIOTransport +from .transports.rest import BackupForGKERestTransport class BackupForGKEClientMeta(type): @@ -67,6 +68,7 @@ class BackupForGKEClientMeta(type): _transport_registry = OrderedDict() # type: Dict[str, Type[BackupForGKETransport]] _transport_registry["grpc"] = BackupForGKEGrpcTransport _transport_registry["grpc_asyncio"] = BackupForGKEGrpcAsyncIOTransport + _transport_registry["rest"] = BackupForGKERestTransport def get_transport_class( cls, @@ -533,6 +535,9 @@ def __init__( transport (Union[str, BackupForGKETransport]): The transport to use. If set to None, a transport is chosen automatically. + NOTE: "rest" transport functionality is currently in a + beta state (preview). We welcome your feedback via an + issue in this library's source repository. client_options (google.api_core.client_options.ClientOptions): Custom options for the client. It won't take effect if a ``transport`` instance is provided. (1) The ``api_endpoint`` property can be used to override the diff --git a/google/cloud/gke_backup_v1/services/backup_for_gke/transports/__init__.py b/google/cloud/gke_backup_v1/services/backup_for_gke/transports/__init__.py index fd05d71..ca63154 100644 --- a/google/cloud/gke_backup_v1/services/backup_for_gke/transports/__init__.py +++ b/google/cloud/gke_backup_v1/services/backup_for_gke/transports/__init__.py @@ -19,15 +19,20 @@ from .base import BackupForGKETransport from .grpc import BackupForGKEGrpcTransport from .grpc_asyncio import BackupForGKEGrpcAsyncIOTransport +from .rest import BackupForGKERestTransport +from .rest import BackupForGKERestInterceptor # Compile a registry of transports. _transport_registry = OrderedDict() # type: Dict[str, Type[BackupForGKETransport]] _transport_registry["grpc"] = BackupForGKEGrpcTransport _transport_registry["grpc_asyncio"] = BackupForGKEGrpcAsyncIOTransport +_transport_registry["rest"] = BackupForGKERestTransport __all__ = ( "BackupForGKETransport", "BackupForGKEGrpcTransport", "BackupForGKEGrpcAsyncIOTransport", + "BackupForGKERestTransport", + "BackupForGKERestInterceptor", ) diff --git a/google/cloud/gke_backup_v1/services/backup_for_gke/transports/rest.py b/google/cloud/gke_backup_v1/services/backup_for_gke/transports/rest.py new file mode 100644 index 0000000..ca86e98 --- /dev/null +++ b/google/cloud/gke_backup_v1/services/backup_for_gke/transports/rest.py @@ -0,0 +1,3304 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +from google.auth.transport.requests import AuthorizedSession # type: ignore +import json # type: ignore +import grpc # type: ignore +from google.auth.transport.grpc import SslCredentials # type: ignore +from google.auth import credentials as ga_credentials # type: ignore +from google.api_core import exceptions as core_exceptions +from google.api_core import retry as retries +from google.api_core import rest_helpers +from google.api_core import rest_streaming +from google.api_core import path_template +from google.api_core import gapic_v1 + +from google.protobuf import json_format +from google.api_core import operations_v1 +from requests import __version__ as requests_version +import dataclasses +import re +from typing import Callable, Dict, List, Optional, Sequence, Tuple, Union +import warnings + +try: + OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault] +except AttributeError: # pragma: NO COVER + OptionalRetry = Union[retries.Retry, object] # type: ignore + + +from google.cloud.gke_backup_v1.types import backup +from google.cloud.gke_backup_v1.types import backup_plan +from google.cloud.gke_backup_v1.types import gkebackup +from google.cloud.gke_backup_v1.types import restore +from google.cloud.gke_backup_v1.types import restore_plan +from google.cloud.gke_backup_v1.types import volume +from google.longrunning import operations_pb2 # type: ignore + +from .base import BackupForGKETransport, DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO + + +DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( + gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version, + grpc_version=None, + rest_version=requests_version, +) + + +class BackupForGKERestInterceptor: + """Interceptor for BackupForGKE. + + Interceptors are used to manipulate requests, request metadata, and responses + in arbitrary ways. + Example use cases include: + * Logging + * Verifying requests according to service or custom semantics + * Stripping extraneous information from responses + + These use cases and more can be enabled by injecting an + instance of a custom subclass when constructing the BackupForGKERestTransport. + + .. code-block:: python + class MyCustomBackupForGKEInterceptor(BackupForGKERestInterceptor): + def pre_create_backup(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_create_backup(response): + logging.log(f"Received response: {response}") + + def pre_create_backup_plan(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_create_backup_plan(response): + logging.log(f"Received response: {response}") + + def pre_create_restore(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_create_restore(response): + logging.log(f"Received response: {response}") + + def pre_create_restore_plan(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_create_restore_plan(response): + logging.log(f"Received response: {response}") + + def pre_delete_backup(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_delete_backup(response): + logging.log(f"Received response: {response}") + + def pre_delete_backup_plan(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_delete_backup_plan(response): + logging.log(f"Received response: {response}") + + def pre_delete_restore(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_delete_restore(response): + logging.log(f"Received response: {response}") + + def pre_delete_restore_plan(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_delete_restore_plan(response): + logging.log(f"Received response: {response}") + + def pre_get_backup(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_backup(response): + logging.log(f"Received response: {response}") + + def pre_get_backup_plan(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_backup_plan(response): + logging.log(f"Received response: {response}") + + def pre_get_restore(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_restore(response): + logging.log(f"Received response: {response}") + + def pre_get_restore_plan(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_restore_plan(response): + logging.log(f"Received response: {response}") + + def pre_get_volume_backup(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_volume_backup(response): + logging.log(f"Received response: {response}") + + def pre_get_volume_restore(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_get_volume_restore(response): + logging.log(f"Received response: {response}") + + def pre_list_backup_plans(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_backup_plans(response): + logging.log(f"Received response: {response}") + + def pre_list_backups(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_backups(response): + logging.log(f"Received response: {response}") + + def pre_list_restore_plans(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_restore_plans(response): + logging.log(f"Received response: {response}") + + def pre_list_restores(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_restores(response): + logging.log(f"Received response: {response}") + + def pre_list_volume_backups(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_volume_backups(response): + logging.log(f"Received response: {response}") + + def pre_list_volume_restores(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_list_volume_restores(response): + logging.log(f"Received response: {response}") + + def pre_update_backup(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_update_backup(response): + logging.log(f"Received response: {response}") + + def pre_update_backup_plan(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_update_backup_plan(response): + logging.log(f"Received response: {response}") + + def pre_update_restore(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_update_restore(response): + logging.log(f"Received response: {response}") + + def pre_update_restore_plan(request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def post_update_restore_plan(response): + logging.log(f"Received response: {response}") + + transport = BackupForGKERestTransport(interceptor=MyCustomBackupForGKEInterceptor()) + client = BackupForGKEClient(transport=transport) + + + """ + + def pre_create_backup( + self, + request: gkebackup.CreateBackupRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.CreateBackupRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for create_backup + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_create_backup( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for create_backup + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_create_backup_plan( + self, + request: gkebackup.CreateBackupPlanRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.CreateBackupPlanRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for create_backup_plan + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_create_backup_plan( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for create_backup_plan + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_create_restore( + self, + request: gkebackup.CreateRestoreRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.CreateRestoreRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for create_restore + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_create_restore( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for create_restore + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_create_restore_plan( + self, + request: gkebackup.CreateRestorePlanRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.CreateRestorePlanRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for create_restore_plan + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_create_restore_plan( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for create_restore_plan + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_delete_backup( + self, + request: gkebackup.DeleteBackupRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.DeleteBackupRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for delete_backup + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_delete_backup( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for delete_backup + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_delete_backup_plan( + self, + request: gkebackup.DeleteBackupPlanRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.DeleteBackupPlanRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for delete_backup_plan + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_delete_backup_plan( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for delete_backup_plan + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_delete_restore( + self, + request: gkebackup.DeleteRestoreRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.DeleteRestoreRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for delete_restore + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_delete_restore( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for delete_restore + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_delete_restore_plan( + self, + request: gkebackup.DeleteRestorePlanRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.DeleteRestorePlanRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for delete_restore_plan + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_delete_restore_plan( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for delete_restore_plan + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_get_backup( + self, request: gkebackup.GetBackupRequest, metadata: Sequence[Tuple[str, str]] + ) -> Tuple[gkebackup.GetBackupRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for get_backup + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_get_backup(self, response: backup.Backup) -> backup.Backup: + """Post-rpc interceptor for get_backup + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_get_backup_plan( + self, + request: gkebackup.GetBackupPlanRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.GetBackupPlanRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for get_backup_plan + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_get_backup_plan( + self, response: backup_plan.BackupPlan + ) -> backup_plan.BackupPlan: + """Post-rpc interceptor for get_backup_plan + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_get_restore( + self, request: gkebackup.GetRestoreRequest, metadata: Sequence[Tuple[str, str]] + ) -> Tuple[gkebackup.GetRestoreRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for get_restore + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_get_restore(self, response: restore.Restore) -> restore.Restore: + """Post-rpc interceptor for get_restore + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_get_restore_plan( + self, + request: gkebackup.GetRestorePlanRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.GetRestorePlanRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for get_restore_plan + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_get_restore_plan( + self, response: restore_plan.RestorePlan + ) -> restore_plan.RestorePlan: + """Post-rpc interceptor for get_restore_plan + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_get_volume_backup( + self, + request: gkebackup.GetVolumeBackupRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.GetVolumeBackupRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for get_volume_backup + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_get_volume_backup( + self, response: volume.VolumeBackup + ) -> volume.VolumeBackup: + """Post-rpc interceptor for get_volume_backup + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_get_volume_restore( + self, + request: gkebackup.GetVolumeRestoreRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.GetVolumeRestoreRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for get_volume_restore + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_get_volume_restore( + self, response: volume.VolumeRestore + ) -> volume.VolumeRestore: + """Post-rpc interceptor for get_volume_restore + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_list_backup_plans( + self, + request: gkebackup.ListBackupPlansRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.ListBackupPlansRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for list_backup_plans + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_list_backup_plans( + self, response: gkebackup.ListBackupPlansResponse + ) -> gkebackup.ListBackupPlansResponse: + """Post-rpc interceptor for list_backup_plans + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_list_backups( + self, request: gkebackup.ListBackupsRequest, metadata: Sequence[Tuple[str, str]] + ) -> Tuple[gkebackup.ListBackupsRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for list_backups + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_list_backups( + self, response: gkebackup.ListBackupsResponse + ) -> gkebackup.ListBackupsResponse: + """Post-rpc interceptor for list_backups + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_list_restore_plans( + self, + request: gkebackup.ListRestorePlansRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.ListRestorePlansRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for list_restore_plans + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_list_restore_plans( + self, response: gkebackup.ListRestorePlansResponse + ) -> gkebackup.ListRestorePlansResponse: + """Post-rpc interceptor for list_restore_plans + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_list_restores( + self, + request: gkebackup.ListRestoresRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.ListRestoresRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for list_restores + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_list_restores( + self, response: gkebackup.ListRestoresResponse + ) -> gkebackup.ListRestoresResponse: + """Post-rpc interceptor for list_restores + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_list_volume_backups( + self, + request: gkebackup.ListVolumeBackupsRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.ListVolumeBackupsRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for list_volume_backups + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_list_volume_backups( + self, response: gkebackup.ListVolumeBackupsResponse + ) -> gkebackup.ListVolumeBackupsResponse: + """Post-rpc interceptor for list_volume_backups + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_list_volume_restores( + self, + request: gkebackup.ListVolumeRestoresRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.ListVolumeRestoresRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for list_volume_restores + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_list_volume_restores( + self, response: gkebackup.ListVolumeRestoresResponse + ) -> gkebackup.ListVolumeRestoresResponse: + """Post-rpc interceptor for list_volume_restores + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_update_backup( + self, + request: gkebackup.UpdateBackupRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.UpdateBackupRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for update_backup + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_update_backup( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for update_backup + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_update_backup_plan( + self, + request: gkebackup.UpdateBackupPlanRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.UpdateBackupPlanRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for update_backup_plan + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_update_backup_plan( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for update_backup_plan + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_update_restore( + self, + request: gkebackup.UpdateRestoreRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.UpdateRestoreRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for update_restore + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_update_restore( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for update_restore + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + def pre_update_restore_plan( + self, + request: gkebackup.UpdateRestorePlanRequest, + metadata: Sequence[Tuple[str, str]], + ) -> Tuple[gkebackup.UpdateRestorePlanRequest, Sequence[Tuple[str, str]]]: + """Pre-rpc interceptor for update_restore_plan + + Override in a subclass to manipulate the request or metadata + before they are sent to the BackupForGKE server. + """ + return request, metadata + + def post_update_restore_plan( + self, response: operations_pb2.Operation + ) -> operations_pb2.Operation: + """Post-rpc interceptor for update_restore_plan + + Override in a subclass to manipulate the response + after it is returned by the BackupForGKE server but before + it is returned to user code. + """ + return response + + +@dataclasses.dataclass +class BackupForGKERestStub: + _session: AuthorizedSession + _host: str + _interceptor: BackupForGKERestInterceptor + + +class BackupForGKERestTransport(BackupForGKETransport): + """REST backend transport for BackupForGKE. + + BackupForGKE allows Kubernetes administrators to configure, + execute, and manage backup and restore operations for their GKE + clusters. + + This class defines the same methods as the primary client, so the + primary client can load the underlying transport implementation + and call it. + + It sends JSON representations of protocol buffers over HTTP/1.1 + + NOTE: This REST transport functionality is currently in a beta + state (preview). We welcome your feedback via an issue in this + library's source repository. Thank you! + """ + + def __init__( + self, + *, + host: str = "gkebackup.googleapis.com", + credentials: ga_credentials.Credentials = None, + credentials_file: str = None, + scopes: Sequence[str] = None, + client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None, + quota_project_id: Optional[str] = None, + client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, + always_use_jwt_access: Optional[bool] = False, + url_scheme: str = "https", + interceptor: Optional[BackupForGKERestInterceptor] = None, + api_audience: Optional[str] = None, + ) -> None: + """Instantiate the transport. + + NOTE: This REST transport functionality is currently in a beta + state (preview). We welcome your feedback via a GitHub issue in + this library's repository. Thank you! + + Args: + host (Optional[str]): + The hostname to connect to. + credentials (Optional[google.auth.credentials.Credentials]): The + authorization credentials to attach to requests. These + credentials identify the application to the service; if none + are specified, the client will attempt to ascertain the + credentials from the environment. + + credentials_file (Optional[str]): A file with credentials that can + be loaded with :func:`google.auth.load_credentials_from_file`. + This argument is ignored if ``channel`` is provided. + scopes (Optional(Sequence[str])): A list of scopes. This argument is + ignored if ``channel`` is provided. + client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client + certificate to configure mutual TLS HTTP channel. It is ignored + if ``channel`` is provided. + quota_project_id (Optional[str]): An optional project to use for billing + and quota. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you are developing + your own client library. + always_use_jwt_access (Optional[bool]): Whether self signed JWT should + be used for service account credentials. + url_scheme: the protocol scheme for the API endpoint. Normally + "https", but for testing or local servers, + "http" can be specified. + """ + # Run the base constructor + # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc. + # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the + # credentials object + maybe_url_match = re.match("^(?Phttp(?:s)?://)?(?P.*)$", host) + if maybe_url_match is None: + raise ValueError( + f"Unexpected hostname structure: {host}" + ) # pragma: NO COVER + + url_match_items = maybe_url_match.groupdict() + + host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host + + super().__init__( + host=host, + credentials=credentials, + client_info=client_info, + always_use_jwt_access=always_use_jwt_access, + api_audience=api_audience, + ) + self._session = AuthorizedSession( + self._credentials, default_host=self.DEFAULT_HOST + ) + self._operations_client: Optional[operations_v1.AbstractOperationsClient] = None + if client_cert_source_for_mtls: + self._session.configure_mtls_channel(client_cert_source_for_mtls) + self._interceptor = interceptor or BackupForGKERestInterceptor() + self._prep_wrapped_messages(client_info) + + @property + def operations_client(self) -> operations_v1.AbstractOperationsClient: + """Create the client designed to process long-running operations. + + This property caches on the instance; repeated calls return the same + client. + """ + # Only create a new client if we do not already have one. + if self._operations_client is None: + http_options: Dict[str, List[Dict[str, str]]] = {} + + rest_transport = operations_v1.OperationsRestTransport( + host=self._host, + # use the credentials which are saved + credentials=self._credentials, + scopes=self._scopes, + http_options=http_options, + ) + + self._operations_client = operations_v1.AbstractOperationsClient( + transport=rest_transport + ) + + # Return the client from cache. + return self._operations_client + + class _CreateBackup(BackupForGKERestStub): + def __hash__(self): + return hash("CreateBackup") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.CreateBackupRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the create backup method over HTTP. + + Args: + request (~.gkebackup.CreateBackupRequest): + The request object. Request message for CreateBackup. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{parent=projects/*/locations/*/backupPlans/*}/backups", + "body": "backup", + }, + ] + request, metadata = self._interceptor.pre_create_backup(request, metadata) + pb_request = gkebackup.CreateBackupRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_create_backup(resp) + return resp + + class _CreateBackupPlan(BackupForGKERestStub): + def __hash__(self): + return hash("CreateBackupPlan") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = { + "backupPlanId": "", + } + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.CreateBackupPlanRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the create backup plan method over HTTP. + + Args: + request (~.gkebackup.CreateBackupPlanRequest): + The request object. Request message for CreateBackupPlan. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{parent=projects/*/locations/*}/backupPlans", + "body": "backup_plan", + }, + ] + request, metadata = self._interceptor.pre_create_backup_plan( + request, metadata + ) + pb_request = gkebackup.CreateBackupPlanRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_create_backup_plan(resp) + return resp + + class _CreateRestore(BackupForGKERestStub): + def __hash__(self): + return hash("CreateRestore") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = { + "restoreId": "", + } + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.CreateRestoreRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the create restore method over HTTP. + + Args: + request (~.gkebackup.CreateRestoreRequest): + The request object. Request message for CreateRestore. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{parent=projects/*/locations/*/restorePlans/*}/restores", + "body": "restore", + }, + ] + request, metadata = self._interceptor.pre_create_restore(request, metadata) + pb_request = gkebackup.CreateRestoreRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_create_restore(resp) + return resp + + class _CreateRestorePlan(BackupForGKERestStub): + def __hash__(self): + return hash("CreateRestorePlan") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = { + "restorePlanId": "", + } + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.CreateRestorePlanRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the create restore plan method over HTTP. + + Args: + request (~.gkebackup.CreateRestorePlanRequest): + The request object. Request message for + CreateRestorePlan. + + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "post", + "uri": "/v1/{parent=projects/*/locations/*}/restorePlans", + "body": "restore_plan", + }, + ] + request, metadata = self._interceptor.pre_create_restore_plan( + request, metadata + ) + pb_request = gkebackup.CreateRestorePlanRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_create_restore_plan(resp) + return resp + + class _DeleteBackup(BackupForGKERestStub): + def __hash__(self): + return hash("DeleteBackup") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.DeleteBackupRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the delete backup method over HTTP. + + Args: + request (~.gkebackup.DeleteBackupRequest): + The request object. Request message for DeleteBackup. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=projects/*/locations/*/backupPlans/*/backups/*}", + }, + ] + request, metadata = self._interceptor.pre_delete_backup(request, metadata) + pb_request = gkebackup.DeleteBackupRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_delete_backup(resp) + return resp + + class _DeleteBackupPlan(BackupForGKERestStub): + def __hash__(self): + return hash("DeleteBackupPlan") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.DeleteBackupPlanRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the delete backup plan method over HTTP. + + Args: + request (~.gkebackup.DeleteBackupPlanRequest): + The request object. Request message for DeleteBackupPlan. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=projects/*/locations/*/backupPlans/*}", + }, + ] + request, metadata = self._interceptor.pre_delete_backup_plan( + request, metadata + ) + pb_request = gkebackup.DeleteBackupPlanRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_delete_backup_plan(resp) + return resp + + class _DeleteRestore(BackupForGKERestStub): + def __hash__(self): + return hash("DeleteRestore") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.DeleteRestoreRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the delete restore method over HTTP. + + Args: + request (~.gkebackup.DeleteRestoreRequest): + The request object. Request message for DeleteRestore. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=projects/*/locations/*/restorePlans/*/restores/*}", + }, + ] + request, metadata = self._interceptor.pre_delete_restore(request, metadata) + pb_request = gkebackup.DeleteRestoreRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_delete_restore(resp) + return resp + + class _DeleteRestorePlan(BackupForGKERestStub): + def __hash__(self): + return hash("DeleteRestorePlan") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.DeleteRestorePlanRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the delete restore plan method over HTTP. + + Args: + request (~.gkebackup.DeleteRestorePlanRequest): + The request object. Request message for + DeleteRestorePlan. + + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=projects/*/locations/*/restorePlans/*}", + }, + ] + request, metadata = self._interceptor.pre_delete_restore_plan( + request, metadata + ) + pb_request = gkebackup.DeleteRestorePlanRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_delete_restore_plan(resp) + return resp + + class _GetBackup(BackupForGKERestStub): + def __hash__(self): + return hash("GetBackup") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.GetBackupRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> backup.Backup: + r"""Call the get backup method over HTTP. + + Args: + request (~.gkebackup.GetBackupRequest): + The request object. Request message for GetBackup. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.backup.Backup: + Represents a request to perform a + single point-in-time capture of some + portion of the state of a GKE cluster, + the record of the backup operation + itself, and an anchor for the underlying + artifacts that comprise the Backup (the + config backup and VolumeBackups). Next + id: 28 + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/backupPlans/*/backups/*}", + }, + ] + request, metadata = self._interceptor.pre_get_backup(request, metadata) + pb_request = gkebackup.GetBackupRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = backup.Backup() + pb_resp = backup.Backup.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_get_backup(resp) + return resp + + class _GetBackupPlan(BackupForGKERestStub): + def __hash__(self): + return hash("GetBackupPlan") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.GetBackupPlanRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> backup_plan.BackupPlan: + r"""Call the get backup plan method over HTTP. + + Args: + request (~.gkebackup.GetBackupPlanRequest): + The request object. Request message for GetBackupPlan. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.backup_plan.BackupPlan: + Defines the configuration and + scheduling for a "line" of Backups. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/backupPlans/*}", + }, + ] + request, metadata = self._interceptor.pre_get_backup_plan(request, metadata) + pb_request = gkebackup.GetBackupPlanRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = backup_plan.BackupPlan() + pb_resp = backup_plan.BackupPlan.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_get_backup_plan(resp) + return resp + + class _GetRestore(BackupForGKERestStub): + def __hash__(self): + return hash("GetRestore") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.GetRestoreRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> restore.Restore: + r"""Call the get restore method over HTTP. + + Args: + request (~.gkebackup.GetRestoreRequest): + The request object. Request message for GetRestore. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.restore.Restore: + Represents both a request to Restore + some portion of a Backup into a target + GKE cluster and a record of the restore + operation itself. Next id: 18 + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/restorePlans/*/restores/*}", + }, + ] + request, metadata = self._interceptor.pre_get_restore(request, metadata) + pb_request = gkebackup.GetRestoreRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = restore.Restore() + pb_resp = restore.Restore.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_get_restore(resp) + return resp + + class _GetRestorePlan(BackupForGKERestStub): + def __hash__(self): + return hash("GetRestorePlan") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.GetRestorePlanRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> restore_plan.RestorePlan: + r"""Call the get restore plan method over HTTP. + + Args: + request (~.gkebackup.GetRestorePlanRequest): + The request object. Request message for GetRestorePlan. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.restore_plan.RestorePlan: + The configuration of a potential + series of Restore operations to be + performed against Backups belong to a + particular BackupPlan. Next id: 11 + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/restorePlans/*}", + }, + ] + request, metadata = self._interceptor.pre_get_restore_plan( + request, metadata + ) + pb_request = gkebackup.GetRestorePlanRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = restore_plan.RestorePlan() + pb_resp = restore_plan.RestorePlan.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_get_restore_plan(resp) + return resp + + class _GetVolumeBackup(BackupForGKERestStub): + def __hash__(self): + return hash("GetVolumeBackup") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.GetVolumeBackupRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> volume.VolumeBackup: + r"""Call the get volume backup method over HTTP. + + Args: + request (~.gkebackup.GetVolumeBackupRequest): + The request object. Request message for GetVolumeBackup. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.volume.VolumeBackup: + Represents the backup of a specific + persistent volume as a component of a + Backup - both the record of the + operation and a pointer to the + underlying storage-specific artifacts. + Next id: 14 + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/backupPlans/*/backups/*/volumeBackups/*}", + }, + ] + request, metadata = self._interceptor.pre_get_volume_backup( + request, metadata + ) + pb_request = gkebackup.GetVolumeBackupRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = volume.VolumeBackup() + pb_resp = volume.VolumeBackup.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_get_volume_backup(resp) + return resp + + class _GetVolumeRestore(BackupForGKERestStub): + def __hash__(self): + return hash("GetVolumeRestore") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.GetVolumeRestoreRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> volume.VolumeRestore: + r"""Call the get volume restore method over HTTP. + + Args: + request (~.gkebackup.GetVolumeRestoreRequest): + The request object. Request message for GetVolumeRestore. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.volume.VolumeRestore: + Represents the operation of restoring + a volume from a VolumeBackup. Next id: + 13 + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{name=projects/*/locations/*/restorePlans/*/restores/*/volumeRestores/*}", + }, + ] + request, metadata = self._interceptor.pre_get_volume_restore( + request, metadata + ) + pb_request = gkebackup.GetVolumeRestoreRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = volume.VolumeRestore() + pb_resp = volume.VolumeRestore.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_get_volume_restore(resp) + return resp + + class _ListBackupPlans(BackupForGKERestStub): + def __hash__(self): + return hash("ListBackupPlans") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.ListBackupPlansRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> gkebackup.ListBackupPlansResponse: + r"""Call the list backup plans method over HTTP. + + Args: + request (~.gkebackup.ListBackupPlansRequest): + The request object. Request message for ListBackupPlans. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.gkebackup.ListBackupPlansResponse: + Response message for ListBackupPlans. + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*}/backupPlans", + }, + ] + request, metadata = self._interceptor.pre_list_backup_plans( + request, metadata + ) + pb_request = gkebackup.ListBackupPlansRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = gkebackup.ListBackupPlansResponse() + pb_resp = gkebackup.ListBackupPlansResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_list_backup_plans(resp) + return resp + + class _ListBackups(BackupForGKERestStub): + def __hash__(self): + return hash("ListBackups") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.ListBackupsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> gkebackup.ListBackupsResponse: + r"""Call the list backups method over HTTP. + + Args: + request (~.gkebackup.ListBackupsRequest): + The request object. Request message for ListBackups. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.gkebackup.ListBackupsResponse: + Response message for ListBackups. + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*/backupPlans/*}/backups", + }, + ] + request, metadata = self._interceptor.pre_list_backups(request, metadata) + pb_request = gkebackup.ListBackupsRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = gkebackup.ListBackupsResponse() + pb_resp = gkebackup.ListBackupsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_list_backups(resp) + return resp + + class _ListRestorePlans(BackupForGKERestStub): + def __hash__(self): + return hash("ListRestorePlans") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.ListRestorePlansRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> gkebackup.ListRestorePlansResponse: + r"""Call the list restore plans method over HTTP. + + Args: + request (~.gkebackup.ListRestorePlansRequest): + The request object. Request message for ListRestorePlans. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.gkebackup.ListRestorePlansResponse: + Response message for + ListRestorePlans. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*}/restorePlans", + }, + ] + request, metadata = self._interceptor.pre_list_restore_plans( + request, metadata + ) + pb_request = gkebackup.ListRestorePlansRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = gkebackup.ListRestorePlansResponse() + pb_resp = gkebackup.ListRestorePlansResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_list_restore_plans(resp) + return resp + + class _ListRestores(BackupForGKERestStub): + def __hash__(self): + return hash("ListRestores") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.ListRestoresRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> gkebackup.ListRestoresResponse: + r"""Call the list restores method over HTTP. + + Args: + request (~.gkebackup.ListRestoresRequest): + The request object. Request message for ListRestores. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.gkebackup.ListRestoresResponse: + Response message for ListRestores. + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*/restorePlans/*}/restores", + }, + ] + request, metadata = self._interceptor.pre_list_restores(request, metadata) + pb_request = gkebackup.ListRestoresRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = gkebackup.ListRestoresResponse() + pb_resp = gkebackup.ListRestoresResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_list_restores(resp) + return resp + + class _ListVolumeBackups(BackupForGKERestStub): + def __hash__(self): + return hash("ListVolumeBackups") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.ListVolumeBackupsRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> gkebackup.ListVolumeBackupsResponse: + r"""Call the list volume backups method over HTTP. + + Args: + request (~.gkebackup.ListVolumeBackupsRequest): + The request object. Request message for + ListVolumeBackups. + + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.gkebackup.ListVolumeBackupsResponse: + Response message for + ListVolumeBackups. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*/backupPlans/*/backups/*}/volumeBackups", + }, + ] + request, metadata = self._interceptor.pre_list_volume_backups( + request, metadata + ) + pb_request = gkebackup.ListVolumeBackupsRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = gkebackup.ListVolumeBackupsResponse() + pb_resp = gkebackup.ListVolumeBackupsResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_list_volume_backups(resp) + return resp + + class _ListVolumeRestores(BackupForGKERestStub): + def __hash__(self): + return hash("ListVolumeRestores") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.ListVolumeRestoresRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> gkebackup.ListVolumeRestoresResponse: + r"""Call the list volume restores method over HTTP. + + Args: + request (~.gkebackup.ListVolumeRestoresRequest): + The request object. Request message for + ListVolumeRestores. + + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.gkebackup.ListVolumeRestoresResponse: + Response message for + ListVolumeRestores. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "get", + "uri": "/v1/{parent=projects/*/locations/*/restorePlans/*/restores/*}/volumeRestores", + }, + ] + request, metadata = self._interceptor.pre_list_volume_restores( + request, metadata + ) + pb_request = gkebackup.ListVolumeRestoresRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = gkebackup.ListVolumeRestoresResponse() + pb_resp = gkebackup.ListVolumeRestoresResponse.pb(resp) + + json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True) + resp = self._interceptor.post_list_volume_restores(resp) + return resp + + class _UpdateBackup(BackupForGKERestStub): + def __hash__(self): + return hash("UpdateBackup") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.UpdateBackupRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the update backup method over HTTP. + + Args: + request (~.gkebackup.UpdateBackupRequest): + The request object. Request message for UpdateBackup. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "patch", + "uri": "/v1/{backup.name=projects/*/locations/*/backupPlans/*/backups/*}", + "body": "backup", + }, + ] + request, metadata = self._interceptor.pre_update_backup(request, metadata) + pb_request = gkebackup.UpdateBackupRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_update_backup(resp) + return resp + + class _UpdateBackupPlan(BackupForGKERestStub): + def __hash__(self): + return hash("UpdateBackupPlan") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.UpdateBackupPlanRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the update backup plan method over HTTP. + + Args: + request (~.gkebackup.UpdateBackupPlanRequest): + The request object. Request message for UpdateBackupPlan. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "patch", + "uri": "/v1/{backup_plan.name=projects/*/locations/*/backupPlans/*}", + "body": "backup_plan", + }, + ] + request, metadata = self._interceptor.pre_update_backup_plan( + request, metadata + ) + pb_request = gkebackup.UpdateBackupPlanRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_update_backup_plan(resp) + return resp + + class _UpdateRestore(BackupForGKERestStub): + def __hash__(self): + return hash("UpdateRestore") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.UpdateRestoreRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the update restore method over HTTP. + + Args: + request (~.gkebackup.UpdateRestoreRequest): + The request object. Request message for UpdateRestore. + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "patch", + "uri": "/v1/{restore.name=projects/*/locations/*/restorePlans/*/restores/*}", + "body": "restore", + }, + ] + request, metadata = self._interceptor.pre_update_restore(request, metadata) + pb_request = gkebackup.UpdateRestoreRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_update_restore(resp) + return resp + + class _UpdateRestorePlan(BackupForGKERestStub): + def __hash__(self): + return hash("UpdateRestorePlan") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + def __call__( + self, + request: gkebackup.UpdateRestorePlanRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: float = None, + metadata: Sequence[Tuple[str, str]] = (), + ) -> operations_pb2.Operation: + r"""Call the update restore plan method over HTTP. + + Args: + request (~.gkebackup.UpdateRestorePlanRequest): + The request object. Request message for + UpdateRestorePlan. + + retry (google.api_core.retry.Retry): Designation of what errors, if any, + should be retried. + timeout (float): The timeout for this request. + metadata (Sequence[Tuple[str, str]]): Strings which should be + sent along with the request as metadata. + + Returns: + ~.operations_pb2.Operation: + This resource represents a + long-running operation that is the + result of a network API call. + + """ + + http_options: List[Dict[str, str]] = [ + { + "method": "patch", + "uri": "/v1/{restore_plan.name=projects/*/locations/*/restorePlans/*}", + "body": "restore_plan", + }, + ] + request, metadata = self._interceptor.pre_update_restore_plan( + request, metadata + ) + pb_request = gkebackup.UpdateRestorePlanRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + + # Jsonify the request body + + body = json_format.MessageToJson( + transcoded_request["body"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + uri = transcoded_request["uri"] + method = transcoded_request["method"] + + # Jsonify the query params + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + query_params.update(self._get_unset_required_fields(query_params)) + + # Send the request + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(self._session, method)( + "{host}{uri}".format(host=self._host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + data=body, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + # Return the response + resp = operations_pb2.Operation() + json_format.Parse(response.content, resp, ignore_unknown_fields=True) + resp = self._interceptor.post_update_restore_plan(resp) + return resp + + @property + def create_backup( + self, + ) -> Callable[[gkebackup.CreateBackupRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._CreateBackup(self._session, self._host, self._interceptor) # type: ignore + + @property + def create_backup_plan( + self, + ) -> Callable[[gkebackup.CreateBackupPlanRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._CreateBackupPlan(self._session, self._host, self._interceptor) # type: ignore + + @property + def create_restore( + self, + ) -> Callable[[gkebackup.CreateRestoreRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._CreateRestore(self._session, self._host, self._interceptor) # type: ignore + + @property + def create_restore_plan( + self, + ) -> Callable[[gkebackup.CreateRestorePlanRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._CreateRestorePlan(self._session, self._host, self._interceptor) # type: ignore + + @property + def delete_backup( + self, + ) -> Callable[[gkebackup.DeleteBackupRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._DeleteBackup(self._session, self._host, self._interceptor) # type: ignore + + @property + def delete_backup_plan( + self, + ) -> Callable[[gkebackup.DeleteBackupPlanRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._DeleteBackupPlan(self._session, self._host, self._interceptor) # type: ignore + + @property + def delete_restore( + self, + ) -> Callable[[gkebackup.DeleteRestoreRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._DeleteRestore(self._session, self._host, self._interceptor) # type: ignore + + @property + def delete_restore_plan( + self, + ) -> Callable[[gkebackup.DeleteRestorePlanRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._DeleteRestorePlan(self._session, self._host, self._interceptor) # type: ignore + + @property + def get_backup(self) -> Callable[[gkebackup.GetBackupRequest], backup.Backup]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._GetBackup(self._session, self._host, self._interceptor) # type: ignore + + @property + def get_backup_plan( + self, + ) -> Callable[[gkebackup.GetBackupPlanRequest], backup_plan.BackupPlan]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._GetBackupPlan(self._session, self._host, self._interceptor) # type: ignore + + @property + def get_restore(self) -> Callable[[gkebackup.GetRestoreRequest], restore.Restore]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._GetRestore(self._session, self._host, self._interceptor) # type: ignore + + @property + def get_restore_plan( + self, + ) -> Callable[[gkebackup.GetRestorePlanRequest], restore_plan.RestorePlan]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._GetRestorePlan(self._session, self._host, self._interceptor) # type: ignore + + @property + def get_volume_backup( + self, + ) -> Callable[[gkebackup.GetVolumeBackupRequest], volume.VolumeBackup]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._GetVolumeBackup(self._session, self._host, self._interceptor) # type: ignore + + @property + def get_volume_restore( + self, + ) -> Callable[[gkebackup.GetVolumeRestoreRequest], volume.VolumeRestore]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._GetVolumeRestore(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_backup_plans( + self, + ) -> Callable[ + [gkebackup.ListBackupPlansRequest], gkebackup.ListBackupPlansResponse + ]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._ListBackupPlans(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_backups( + self, + ) -> Callable[[gkebackup.ListBackupsRequest], gkebackup.ListBackupsResponse]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._ListBackups(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_restore_plans( + self, + ) -> Callable[ + [gkebackup.ListRestorePlansRequest], gkebackup.ListRestorePlansResponse + ]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._ListRestorePlans(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_restores( + self, + ) -> Callable[[gkebackup.ListRestoresRequest], gkebackup.ListRestoresResponse]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._ListRestores(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_volume_backups( + self, + ) -> Callable[ + [gkebackup.ListVolumeBackupsRequest], gkebackup.ListVolumeBackupsResponse + ]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._ListVolumeBackups(self._session, self._host, self._interceptor) # type: ignore + + @property + def list_volume_restores( + self, + ) -> Callable[ + [gkebackup.ListVolumeRestoresRequest], gkebackup.ListVolumeRestoresResponse + ]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._ListVolumeRestores(self._session, self._host, self._interceptor) # type: ignore + + @property + def update_backup( + self, + ) -> Callable[[gkebackup.UpdateBackupRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._UpdateBackup(self._session, self._host, self._interceptor) # type: ignore + + @property + def update_backup_plan( + self, + ) -> Callable[[gkebackup.UpdateBackupPlanRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._UpdateBackupPlan(self._session, self._host, self._interceptor) # type: ignore + + @property + def update_restore( + self, + ) -> Callable[[gkebackup.UpdateRestoreRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._UpdateRestore(self._session, self._host, self._interceptor) # type: ignore + + @property + def update_restore_plan( + self, + ) -> Callable[[gkebackup.UpdateRestorePlanRequest], operations_pb2.Operation]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._UpdateRestorePlan(self._session, self._host, self._interceptor) # type: ignore + + @property + def kind(self) -> str: + return "rest" + + def close(self): + self._session.close() + + +__all__ = ("BackupForGKERestTransport",) diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_ba40475b.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_ba40475b.py new file mode 100644 index 0000000..2c0b8fa --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_ba40475b.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateBackupPlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_CreateBackupPlan_sync_ba40475b] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_create_backup_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + backup_plan = gke_backup_v1.BackupPlan() + backup_plan.cluster = "cluster_value" + + request = gke_backup_v1.CreateBackupPlanRequest( + parent="parent_value", + backup_plan=backup_plan, + backup_plan_id="backup_plan_id_value", + ) + + # Make the request + operation = client.create_backup_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_CreateBackupPlan_sync_ba40475b] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_f9f9cad1.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_f9f9cad1.py new file mode 100644 index 0000000..8cdfbd5 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_f9f9cad1.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateBackupPlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_CreateBackupPlan_sync_f9f9cad1] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_create_backup_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + backup_plan = gke_backup_v1.BackupPlan() + backup_plan.cluster = "cluster_value" + + request = gke_backup_v1.CreateBackupPlanRequest( + parent="parent_value", + backup_plan=backup_plan, + backup_plan_id="backup_plan_id_value", + ) + + # Make the request + operation = client.create_backup_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_CreateBackupPlan_sync_f9f9cad1] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_sync_a203f0cf.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_sync_a203f0cf.py new file mode 100644 index 0000000..64e891c --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_sync_a203f0cf.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_CreateBackup_sync_a203f0cf] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_create_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.CreateBackupRequest( + parent="parent_value", + ) + + # Make the request + operation = client.create_backup(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_CreateBackup_sync_a203f0cf] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_sync_fc39e6b6.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_sync_fc39e6b6.py new file mode 100644 index 0000000..49a8c6b --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_backup_sync_fc39e6b6.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_CreateBackup_sync_fc39e6b6] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_create_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.CreateBackupRequest( + parent="parent_value", + ) + + # Make the request + operation = client.create_backup(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_CreateBackup_sync_fc39e6b6] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_2a7b82f0.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_2a7b82f0.py new file mode 100644 index 0000000..dbe7d6b --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_2a7b82f0.py @@ -0,0 +1,63 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateRestorePlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_CreateRestorePlan_sync_2a7b82f0] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_create_restore_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + restore_plan = gke_backup_v1.RestorePlan() + restore_plan.backup_plan = "backup_plan_value" + restore_plan.cluster = "cluster_value" + restore_plan.restore_config.all_namespaces = True + + request = gke_backup_v1.CreateRestorePlanRequest( + parent="parent_value", + restore_plan=restore_plan, + restore_plan_id="restore_plan_id_value", + ) + + # Make the request + operation = client.create_restore_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_CreateRestorePlan_sync_2a7b82f0] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_f481a3ea.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_f481a3ea.py new file mode 100644 index 0000000..fe15be1 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_f481a3ea.py @@ -0,0 +1,63 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateRestorePlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_CreateRestorePlan_sync_f481a3ea] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_create_restore_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + restore_plan = gke_backup_v1.RestorePlan() + restore_plan.backup_plan = "backup_plan_value" + restore_plan.cluster = "cluster_value" + restore_plan.restore_config.all_namespaces = True + + request = gke_backup_v1.CreateRestorePlanRequest( + parent="parent_value", + restore_plan=restore_plan, + restore_plan_id="restore_plan_id_value", + ) + + # Make the request + operation = client.create_restore_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_CreateRestorePlan_sync_f481a3ea] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_sync_1b49290c.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_sync_1b49290c.py new file mode 100644 index 0000000..f82fea9 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_sync_1b49290c.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_CreateRestore_sync_1b49290c] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_create_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + restore = gke_backup_v1.Restore() + restore.backup = "backup_value" + + request = gke_backup_v1.CreateRestoreRequest( + parent="parent_value", + restore=restore, + restore_id="restore_id_value", + ) + + # Make the request + operation = client.create_restore(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_CreateRestore_sync_1b49290c] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_sync_232e398c.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_sync_232e398c.py new file mode 100644 index 0000000..6e8eb63 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_create_restore_sync_232e398c.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_CreateRestore_sync_232e398c] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_create_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + restore = gke_backup_v1.Restore() + restore.backup = "backup_value" + + request = gke_backup_v1.CreateRestoreRequest( + parent="parent_value", + restore=restore, + restore_id="restore_id_value", + ) + + # Make the request + operation = client.create_restore(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_CreateRestore_sync_232e398c] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_22193aa7.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_22193aa7.py new file mode 100644 index 0000000..d98b9ab --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_22193aa7.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteBackupPlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_DeleteBackupPlan_sync_22193aa7] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_delete_backup_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.DeleteBackupPlanRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_backup_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_DeleteBackupPlan_sync_22193aa7] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_af958d29.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_af958d29.py new file mode 100644 index 0000000..4067093 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_af958d29.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteBackupPlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_DeleteBackupPlan_sync_af958d29] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_delete_backup_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.DeleteBackupPlanRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_backup_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_DeleteBackupPlan_sync_af958d29] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_sync_4e6838b6.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_sync_4e6838b6.py new file mode 100644 index 0000000..74a99f3 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_sync_4e6838b6.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_DeleteBackup_sync_4e6838b6] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_delete_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.DeleteBackupRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_backup(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_DeleteBackup_sync_4e6838b6] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_sync_ba357f30.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_sync_ba357f30.py new file mode 100644 index 0000000..f9ffaef --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_backup_sync_ba357f30.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_DeleteBackup_sync_ba357f30] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_delete_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.DeleteBackupRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_backup(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_DeleteBackup_sync_ba357f30] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_0dd6c9ab.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_0dd6c9ab.py new file mode 100644 index 0000000..f823082 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_0dd6c9ab.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteRestorePlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_DeleteRestorePlan_sync_0dd6c9ab] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_delete_restore_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.DeleteRestorePlanRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_restore_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_DeleteRestorePlan_sync_0dd6c9ab] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_be5aebc4.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_be5aebc4.py new file mode 100644 index 0000000..188e3a5 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_be5aebc4.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteRestorePlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_DeleteRestorePlan_sync_be5aebc4] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_delete_restore_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.DeleteRestorePlanRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_restore_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_DeleteRestorePlan_sync_be5aebc4] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_sync_384f893e.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_sync_384f893e.py new file mode 100644 index 0000000..cf276ab --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_sync_384f893e.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_DeleteRestore_sync_384f893e] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_delete_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.DeleteRestoreRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_restore(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_DeleteRestore_sync_384f893e] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_sync_5725835d.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_sync_5725835d.py new file mode 100644 index 0000000..772f7b8 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_delete_restore_sync_5725835d.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_DeleteRestore_sync_5725835d] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_delete_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.DeleteRestoreRequest( + name="name_value", + ) + + # Make the request + operation = client.delete_restore(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_DeleteRestore_sync_5725835d] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_28db290d.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_28db290d.py new file mode 100644 index 0000000..5c186ba --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_28db290d.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetBackupPlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetBackupPlan_sync_28db290d] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_backup_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetBackupPlanRequest( + name="name_value", + ) + + # Make the request + response = client.get_backup_plan(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetBackupPlan_sync_28db290d] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_afe8a7c5.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_afe8a7c5.py new file mode 100644 index 0000000..5d7f35f --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_afe8a7c5.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetBackupPlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetBackupPlan_sync_afe8a7c5] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_backup_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetBackupPlanRequest( + name="name_value", + ) + + # Make the request + response = client.get_backup_plan(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetBackupPlan_sync_afe8a7c5] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_sync_07911578.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_sync_07911578.py new file mode 100644 index 0000000..9915db0 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_sync_07911578.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetBackup_sync_07911578] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetBackupRequest( + name="name_value", + ) + + # Make the request + response = client.get_backup(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetBackup_sync_07911578] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_sync_e9cf234f.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_sync_e9cf234f.py new file mode 100644 index 0000000..70c13cf --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_backup_sync_e9cf234f.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetBackup_sync_e9cf234f] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetBackupRequest( + name="name_value", + ) + + # Make the request + response = client.get_backup(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetBackup_sync_e9cf234f] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_16da5c9f.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_16da5c9f.py new file mode 100644 index 0000000..1be5dd5 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_16da5c9f.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetRestorePlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetRestorePlan_sync_16da5c9f] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_restore_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetRestorePlanRequest( + name="name_value", + ) + + # Make the request + response = client.get_restore_plan(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetRestorePlan_sync_16da5c9f] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_c4c27d89.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_c4c27d89.py new file mode 100644 index 0000000..5cadd16 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_c4c27d89.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetRestorePlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetRestorePlan_sync_c4c27d89] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_restore_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetRestorePlanRequest( + name="name_value", + ) + + # Make the request + response = client.get_restore_plan(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetRestorePlan_sync_c4c27d89] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_sync_5d9ab521.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_sync_5d9ab521.py new file mode 100644 index 0000000..d809ceb --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_sync_5d9ab521.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetRestore_sync_5d9ab521] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetRestoreRequest( + name="name_value", + ) + + # Make the request + response = client.get_restore(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetRestore_sync_5d9ab521] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_sync_9527929a.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_sync_9527929a.py new file mode 100644 index 0000000..ee29897 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_restore_sync_9527929a.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetRestore_sync_9527929a] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetRestoreRequest( + name="name_value", + ) + + # Make the request + response = client.get_restore(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetRestore_sync_9527929a] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_315e3ab4.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_315e3ab4.py new file mode 100644 index 0000000..a4a095a --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_315e3ab4.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetVolumeBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetVolumeBackup_sync_315e3ab4] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_volume_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetVolumeBackupRequest( + name="name_value", + ) + + # Make the request + response = client.get_volume_backup(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetVolumeBackup_sync_315e3ab4] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_c8db7aee.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_c8db7aee.py new file mode 100644 index 0000000..5402024 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_c8db7aee.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetVolumeBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetVolumeBackup_sync_c8db7aee] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_volume_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetVolumeBackupRequest( + name="name_value", + ) + + # Make the request + response = client.get_volume_backup(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetVolumeBackup_sync_c8db7aee] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_746cfb01.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_746cfb01.py new file mode 100644 index 0000000..2829868 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_746cfb01.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetVolumeRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetVolumeRestore_sync_746cfb01] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_volume_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetVolumeRestoreRequest( + name="name_value", + ) + + # Make the request + response = client.get_volume_restore(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetVolumeRestore_sync_746cfb01] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_8da989ef.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_8da989ef.py new file mode 100644 index 0000000..b04e1c7 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_8da989ef.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetVolumeRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_GetVolumeRestore_sync_8da989ef] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_get_volume_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.GetVolumeRestoreRequest( + name="name_value", + ) + + # Make the request + response = client.get_volume_restore(request=request) + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_GetVolumeRestore_sync_8da989ef] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_5ec6dd54.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_5ec6dd54.py new file mode 100644 index 0000000..a381f58 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_5ec6dd54.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListBackupPlans +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListBackupPlans_sync_5ec6dd54] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_backup_plans(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListBackupPlansRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_backup_plans(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListBackupPlans_sync_5ec6dd54] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_60016b65.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_60016b65.py new file mode 100644 index 0000000..ce7b532 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_60016b65.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListBackupPlans +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListBackupPlans_sync_60016b65] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_backup_plans(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListBackupPlansRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_backup_plans(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListBackupPlans_sync_60016b65] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backups_sync_7da6881e.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backups_sync_7da6881e.py new file mode 100644 index 0000000..247ccca --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backups_sync_7da6881e.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListBackups +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListBackups_sync_7da6881e] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_backups(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListBackupsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_backups(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListBackups_sync_7da6881e] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backups_sync_a7e57cb2.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backups_sync_a7e57cb2.py new file mode 100644 index 0000000..f0675e1 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_backups_sync_a7e57cb2.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListBackups +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListBackups_sync_a7e57cb2] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_backups(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListBackupsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_backups(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListBackups_sync_a7e57cb2] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_9e86e9ed.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_9e86e9ed.py new file mode 100644 index 0000000..050d5ff --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_9e86e9ed.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListRestorePlans +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListRestorePlans_sync_9e86e9ed] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_restore_plans(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListRestorePlansRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_restore_plans(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListRestorePlans_sync_9e86e9ed] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_ac5c3de5.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_ac5c3de5.py new file mode 100644 index 0000000..f438dff --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_ac5c3de5.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListRestorePlans +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListRestorePlans_sync_ac5c3de5] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_restore_plans(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListRestorePlansRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_restore_plans(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListRestorePlans_sync_ac5c3de5] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restores_sync_003c4a18.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restores_sync_003c4a18.py new file mode 100644 index 0000000..05b6b38 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restores_sync_003c4a18.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListRestores +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListRestores_sync_003c4a18] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_restores(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListRestoresRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_restores(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListRestores_sync_003c4a18] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restores_sync_c52e2c76.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restores_sync_c52e2c76.py new file mode 100644 index 0000000..dcdbc60 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_restores_sync_c52e2c76.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListRestores +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListRestores_sync_c52e2c76] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_restores(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListRestoresRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_restores(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListRestores_sync_c52e2c76] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_66d26f94.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_66d26f94.py new file mode 100644 index 0000000..817f9eb --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_66d26f94.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListVolumeBackups +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListVolumeBackups_sync_66d26f94] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_volume_backups(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListVolumeBackupsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_volume_backups(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListVolumeBackups_sync_66d26f94] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_b686a40a.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_b686a40a.py new file mode 100644 index 0000000..88d0efa --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_b686a40a.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListVolumeBackups +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListVolumeBackups_sync_b686a40a] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_volume_backups(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListVolumeBackupsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_volume_backups(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListVolumeBackups_sync_b686a40a] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_96c127d6.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_96c127d6.py new file mode 100644 index 0000000..25817f2 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_96c127d6.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListVolumeRestores +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListVolumeRestores_sync_96c127d6] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_volume_restores(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListVolumeRestoresRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_volume_restores(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListVolumeRestores_sync_96c127d6] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_e6df2c15.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_e6df2c15.py new file mode 100644 index 0000000..5780639 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_e6df2c15.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListVolumeRestores +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_ListVolumeRestores_sync_e6df2c15] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_list_volume_restores(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + request = gke_backup_v1.ListVolumeRestoresRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_volume_restores(request=request) + + # Handle the response + for response in page_result: + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_ListVolumeRestores_sync_e6df2c15] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_240d1e05.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_240d1e05.py new file mode 100644 index 0000000..6bdb9f5 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_240d1e05.py @@ -0,0 +1,59 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateBackupPlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_UpdateBackupPlan_sync_240d1e05] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_update_backup_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + backup_plan = gke_backup_v1.BackupPlan() + backup_plan.cluster = "cluster_value" + + request = gke_backup_v1.UpdateBackupPlanRequest( + backup_plan=backup_plan, + ) + + # Make the request + operation = client.update_backup_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_UpdateBackupPlan_sync_240d1e05] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_e9cd4e74.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_e9cd4e74.py new file mode 100644 index 0000000..54f6a89 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_e9cd4e74.py @@ -0,0 +1,59 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateBackupPlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_UpdateBackupPlan_sync_e9cd4e74] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_update_backup_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + backup_plan = gke_backup_v1.BackupPlan() + backup_plan.cluster = "cluster_value" + + request = gke_backup_v1.UpdateBackupPlanRequest( + backup_plan=backup_plan, + ) + + # Make the request + operation = client.update_backup_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_UpdateBackupPlan_sync_e9cd4e74] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_sync_701ec3bb.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_sync_701ec3bb.py new file mode 100644 index 0000000..b26e590 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_sync_701ec3bb.py @@ -0,0 +1,59 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_UpdateBackup_sync_701ec3bb] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_update_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + backup = gke_backup_v1.Backup() + backup.all_namespaces = True + + request = gke_backup_v1.UpdateBackupRequest( + backup=backup, + ) + + # Make the request + operation = client.update_backup(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_UpdateBackup_sync_701ec3bb] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_sync_c44e40c5.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_sync_c44e40c5.py new file mode 100644 index 0000000..bcb0209 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_backup_sync_c44e40c5.py @@ -0,0 +1,59 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateBackup +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_UpdateBackup_sync_c44e40c5] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_update_backup(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + backup = gke_backup_v1.Backup() + backup.all_namespaces = True + + request = gke_backup_v1.UpdateBackupRequest( + backup=backup, + ) + + # Make the request + operation = client.update_backup(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_UpdateBackup_sync_c44e40c5] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_a36705f8.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_a36705f8.py new file mode 100644 index 0000000..b4ddc72 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_a36705f8.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateRestorePlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_UpdateRestorePlan_sync_a36705f8] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_update_restore_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + restore_plan = gke_backup_v1.RestorePlan() + restore_plan.backup_plan = "backup_plan_value" + restore_plan.cluster = "cluster_value" + restore_plan.restore_config.all_namespaces = True + + request = gke_backup_v1.UpdateRestorePlanRequest( + restore_plan=restore_plan, + ) + + # Make the request + operation = client.update_restore_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_UpdateRestorePlan_sync_a36705f8] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_b115a29d.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_b115a29d.py new file mode 100644 index 0000000..acd9c8c --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_b115a29d.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateRestorePlan +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_UpdateRestorePlan_sync_b115a29d] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_update_restore_plan(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + restore_plan = gke_backup_v1.RestorePlan() + restore_plan.backup_plan = "backup_plan_value" + restore_plan.cluster = "cluster_value" + restore_plan.restore_config.all_namespaces = True + + request = gke_backup_v1.UpdateRestorePlanRequest( + restore_plan=restore_plan, + ) + + # Make the request + operation = client.update_restore_plan(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_UpdateRestorePlan_sync_b115a29d] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_sync_01ce4e95.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_sync_01ce4e95.py new file mode 100644 index 0000000..00fada9 --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_sync_01ce4e95.py @@ -0,0 +1,59 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_UpdateRestore_sync_01ce4e95] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_update_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + restore = gke_backup_v1.Restore() + restore.backup = "backup_value" + + request = gke_backup_v1.UpdateRestoreRequest( + restore=restore, + ) + + # Make the request + operation = client.update_restore(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_UpdateRestore_sync_01ce4e95] diff --git a/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_sync_f27381f8.py b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_sync_f27381f8.py new file mode 100644 index 0000000..f87aafd --- /dev/null +++ b/samples/generated_samples/gkebackup_v1_generated_backup_for_gke_update_restore_sync_f27381f8.py @@ -0,0 +1,59 @@ +# -*- coding: utf-8 -*- +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateRestore +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-cloud-gke-backup + + +# [START gkebackup_v1_generated_BackupForGKE_UpdateRestore_sync_f27381f8] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.cloud import gke_backup_v1 + + +def sample_update_restore(): + # Create a client + client = gke_backup_v1.BackupForGKEClient() + + # Initialize request argument(s) + restore = gke_backup_v1.Restore() + restore.backup = "backup_value" + + request = gke_backup_v1.UpdateRestoreRequest( + restore=restore, + ) + + # Make the request + operation = client.update_restore(request=request) + + print("Waiting for operation to complete...") + + response = operation.result() + + # Handle the response + print(response) + +# [END gkebackup_v1_generated_BackupForGKE_UpdateRestore_sync_f27381f8] diff --git a/samples/generated_samples/snippet_metadata_gke backup_v1.json b/samples/generated_samples/snippet_metadata_gke backup_v1.json index 5120d53..d4b2a6a 100644 --- a/samples/generated_samples/snippet_metadata_gke backup_v1.json +++ b/samples/generated_samples/snippet_metadata_gke backup_v1.json @@ -149,7 +149,7 @@ "shortName": "create_backup_plan" }, "description": "Sample for CreateBackupPlan", - "file": "gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync.py", + "file": "gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_f9f9cad1.py", "language": "PYTHON", "origin": "API_DEFINITION", "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateBackupPlan_sync", @@ -185,7 +185,95 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_f9f9cad1.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.create_backup_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.CreateBackupPlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "CreateBackupPlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.CreateBackupPlanRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "backup_plan", + "type": "google.cloud.gke_backup_v1.types.BackupPlan" + }, + { + "name": "backup_plan_id", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "create_backup_plan" + }, + "description": "Sample for CreateBackupPlan", + "file": "gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_ba40475b.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateBackupPlan_sync", + "segments": [ + { + "end": 60, + "start": 27, + "type": "FULL" + }, + { + "end": 60, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 50, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 57, + "start": 51, + "type": "REQUEST_EXECUTION" + }, + { + "end": 61, + "start": 58, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_create_backup_plan_sync_ba40475b.py" }, { "canonical": true, @@ -326,7 +414,95 @@ "shortName": "create_backup" }, "description": "Sample for CreateBackup", - "file": "gkebackup_v1_generated_backup_for_gke_create_backup_sync.py", + "file": "gkebackup_v1_generated_backup_for_gke_create_backup_sync_a203f0cf.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateBackup_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_create_backup_sync_a203f0cf.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.create_backup", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.CreateBackup", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "CreateBackup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.CreateBackupRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "backup", + "type": "google.cloud.gke_backup_v1.types.Backup" + }, + { + "name": "backup_id", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "create_backup" + }, + "description": "Sample for CreateBackup", + "file": "gkebackup_v1_generated_backup_for_gke_create_backup_sync_fc39e6b6.py", "language": "PYTHON", "origin": "API_DEFINITION", "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateBackup_sync", @@ -362,7 +538,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_create_backup_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_create_backup_sync_fc39e6b6.py" }, { "canonical": true, @@ -503,7 +679,7 @@ "shortName": "create_restore_plan" }, "description": "Sample for CreateRestorePlan", - "file": "gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync.py", + "file": "gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_f481a3ea.py", "language": "PYTHON", "origin": "API_DEFINITION", "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateRestorePlan_sync", @@ -539,40 +715,39 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_f481a3ea.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.create_restore", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.create_restore_plan", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.CreateRestore", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.CreateRestorePlan", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "CreateRestore" + "shortName": "CreateRestorePlan" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.CreateRestoreRequest" + "type": "google.cloud.gke_backup_v1.types.CreateRestorePlanRequest" }, { "name": "parent", "type": "str" }, { - "name": "restore", - "type": "google.cloud.gke_backup_v1.types.Restore" + "name": "restore_plan", + "type": "google.cloud.gke_backup_v1.types.RestorePlan" }, { - "name": "restore_id", + "name": "restore_plan_id", "type": "str" }, { @@ -588,22 +763,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "create_restore" + "resultType": "google.api_core.operation.Operation", + "shortName": "create_restore_plan" }, - "description": "Sample for CreateRestore", - "file": "gkebackup_v1_generated_backup_for_gke_create_restore_async.py", + "description": "Sample for CreateRestorePlan", + "file": "gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_2a7b82f0.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateRestore_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateRestorePlan_sync", "segments": [ { - "end": 60, + "end": 62, "start": 27, "type": "FULL" }, { - "end": 60, + "end": 62, "start": 27, "type": "SHORT" }, @@ -613,31 +788,32 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 50, + "end": 52, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 57, - "start": 51, + "end": 59, + "start": 53, "type": "REQUEST_EXECUTION" }, { - "end": 61, - "start": 58, + "end": 63, + "start": 60, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_create_restore_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_create_restore_plan_sync_2a7b82f0.py" }, { "canonical": true, "clientMethod": { + "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", - "shortName": "BackupForGKEClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.create_restore", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.create_restore", "method": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE.CreateRestore", "service": { @@ -676,14 +852,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation.Operation", + "resultType": "google.api_core.operation_async.AsyncOperation", "shortName": "create_restore" }, "description": "Sample for CreateRestore", - "file": "gkebackup_v1_generated_backup_for_gke_create_restore_sync.py", + "file": "gkebackup_v1_generated_backup_for_gke_create_restore_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateRestore_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateRestore_async", "segments": [ { "end": 60, @@ -716,32 +892,39 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_create_restore_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_create_restore_async.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.delete_backup_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.create_restore", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackupPlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.CreateRestore", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "DeleteBackupPlan" + "shortName": "CreateRestore" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.DeleteBackupPlanRequest" + "type": "google.cloud.gke_backup_v1.types.CreateRestoreRequest" }, { - "name": "name", + "name": "parent", + "type": "str" + }, + { + "name": "restore", + "type": "google.cloud.gke_backup_v1.types.Restore" + }, + { + "name": "restore_id", "type": "str" }, { @@ -757,10 +940,179 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "delete_backup_plan" + "resultType": "google.api_core.operation.Operation", + "shortName": "create_restore" }, - "description": "Sample for DeleteBackupPlan", + "description": "Sample for CreateRestore", + "file": "gkebackup_v1_generated_backup_for_gke_create_restore_sync_232e398c.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateRestore_sync", + "segments": [ + { + "end": 60, + "start": 27, + "type": "FULL" + }, + { + "end": 60, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 50, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 57, + "start": 51, + "type": "REQUEST_EXECUTION" + }, + { + "end": 61, + "start": 58, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_create_restore_sync_232e398c.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.create_restore", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.CreateRestore", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "CreateRestore" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.CreateRestoreRequest" + }, + { + "name": "parent", + "type": "str" + }, + { + "name": "restore", + "type": "google.cloud.gke_backup_v1.types.Restore" + }, + { + "name": "restore_id", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "create_restore" + }, + "description": "Sample for CreateRestore", + "file": "gkebackup_v1_generated_backup_for_gke_create_restore_sync_1b49290c.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_CreateRestore_sync", + "segments": [ + { + "end": 60, + "start": 27, + "type": "FULL" + }, + { + "end": 60, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 50, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 57, + "start": 51, + "type": "REQUEST_EXECUTION" + }, + { + "end": 61, + "start": 58, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_create_restore_sync_1b49290c.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.delete_backup_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackupPlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteBackupPlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteBackupPlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "delete_backup_plan" + }, + "description": "Sample for DeleteBackupPlan", "file": "gkebackup_v1_generated_backup_for_gke_delete_backup_plan_async.py", "language": "PYTHON", "origin": "API_DEFINITION", @@ -792,12 +1144,1538 @@ "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_plan_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_backup_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackupPlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteBackupPlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteBackupPlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_backup_plan" + }, + "description": "Sample for DeleteBackupPlan", + "file": "gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_22193aa7.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteBackupPlan_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_22193aa7.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_backup_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackupPlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteBackupPlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteBackupPlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_backup_plan" + }, + "description": "Sample for DeleteBackupPlan", + "file": "gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_af958d29.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteBackupPlan_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync_af958d29.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.delete_backup", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackup", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteBackup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteBackupRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "delete_backup" + }, + "description": "Sample for DeleteBackup", + "file": "gkebackup_v1_generated_backup_for_gke_delete_backup_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteBackup_async", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_backup", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackup", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteBackup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteBackupRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_backup" + }, + "description": "Sample for DeleteBackup", + "file": "gkebackup_v1_generated_backup_for_gke_delete_backup_sync_ba357f30.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteBackup_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_sync_ba357f30.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_backup", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackup", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteBackup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteBackupRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_backup" + }, + "description": "Sample for DeleteBackup", + "file": "gkebackup_v1_generated_backup_for_gke_delete_backup_sync_4e6838b6.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteBackup_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_sync_4e6838b6.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.delete_restore_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestorePlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteRestorePlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteRestorePlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "delete_restore_plan" + }, + "description": "Sample for DeleteRestorePlan", + "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestorePlan_async", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_restore_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestorePlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteRestorePlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteRestorePlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_restore_plan" + }, + "description": "Sample for DeleteRestorePlan", + "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_be5aebc4.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestorePlan_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_be5aebc4.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_restore_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestorePlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteRestorePlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteRestorePlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_restore_plan" + }, + "description": "Sample for DeleteRestorePlan", + "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_0dd6c9ab.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestorePlan_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync_0dd6c9ab.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.delete_restore", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestore", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteRestore" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteRestoreRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "delete_restore" + }, + "description": "Sample for DeleteRestore", + "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestore_async", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_restore", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestore", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteRestore" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteRestoreRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_restore" + }, + "description": "Sample for DeleteRestore", + "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_sync_384f893e.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestore_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_sync_384f893e.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_restore", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestore", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "DeleteRestore" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.DeleteRestoreRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "delete_restore" + }, + "description": "Sample for DeleteRestore", + "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_sync_5725835d.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestore_sync", + "segments": [ + { + "end": 55, + "start": 27, + "type": "FULL" + }, + { + "end": 55, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 52, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 56, + "start": 53, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_sync_5725835d.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_backup_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackupPlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "GetBackupPlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.GetBackupPlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.gke_backup_v1.types.BackupPlan", + "shortName": "get_backup_plan" + }, + "description": "Sample for GetBackupPlan", + "file": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackupPlan_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_backup_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackupPlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "GetBackupPlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.GetBackupPlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.gke_backup_v1.types.BackupPlan", + "shortName": "get_backup_plan" + }, + "description": "Sample for GetBackupPlan", + "file": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_28db290d.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackupPlan_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_28db290d.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_backup_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackupPlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "GetBackupPlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.GetBackupPlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.gke_backup_v1.types.BackupPlan", + "shortName": "get_backup_plan" + }, + "description": "Sample for GetBackupPlan", + "file": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_afe8a7c5.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackupPlan_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync_afe8a7c5.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_backup", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackup", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "GetBackup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.GetBackupRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.gke_backup_v1.types.Backup", + "shortName": "get_backup" + }, + "description": "Sample for GetBackup", + "file": "gkebackup_v1_generated_backup_for_gke_get_backup_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackup_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_get_backup_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_backup", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackup", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "GetBackup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.GetBackupRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.gke_backup_v1.types.Backup", + "shortName": "get_backup" + }, + "description": "Sample for GetBackup", + "file": "gkebackup_v1_generated_backup_for_gke_get_backup_sync_07911578.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackup_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_get_backup_sync_07911578.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_backup", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackup", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "GetBackup" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.GetBackupRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.gke_backup_v1.types.Backup", + "shortName": "get_backup" + }, + "description": "Sample for GetBackup", + "file": "gkebackup_v1_generated_backup_for_gke_get_backup_sync_e9cf234f.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackup_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_get_backup_sync_e9cf234f.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_restore_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestorePlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "GetRestorePlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.GetRestorePlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.gke_backup_v1.types.RestorePlan", + "shortName": "get_restore_plan" + }, + "description": "Sample for GetRestorePlan", + "file": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestorePlan_async", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_restore_plan", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestorePlan", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "GetRestorePlan" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.GetRestorePlanRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.gke_backup_v1.types.RestorePlan", + "shortName": "get_restore_plan" + }, + "description": "Sample for GetRestorePlan", + "file": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_16da5c9f.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestorePlan_sync", + "segments": [ + { + "end": 51, + "start": 27, + "type": "FULL" + }, + { + "end": 51, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 48, + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_plan_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_16da5c9f.py" }, { "canonical": true, @@ -806,19 +2684,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_backup_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_restore_plan", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackupPlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestorePlan", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "DeleteBackupPlan" + "shortName": "GetRestorePlan" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.DeleteBackupPlanRequest" + "type": "google.cloud.gke_backup_v1.types.GetRestorePlanRequest" }, { "name": "name", @@ -837,22 +2715,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation.Operation", - "shortName": "delete_backup_plan" + "resultType": "google.cloud.gke_backup_v1.types.RestorePlan", + "shortName": "get_restore_plan" }, - "description": "Sample for DeleteBackupPlan", - "file": "gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync.py", + "description": "Sample for GetRestorePlan", + "file": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_c4c27d89.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteBackupPlan_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestorePlan_sync", "segments": [ { - "end": 55, + "end": 51, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 51, "start": 27, "type": "SHORT" }, @@ -867,17 +2745,17 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 52, + "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_plan_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync_c4c27d89.py" }, { "canonical": true, @@ -887,19 +2765,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.delete_backup", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_restore", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackup", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestore", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "DeleteBackup" + "shortName": "GetRestore" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.DeleteBackupRequest" + "type": "google.cloud.gke_backup_v1.types.GetRestoreRequest" }, { "name": "name", @@ -918,22 +2796,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "delete_backup" + "resultType": "google.cloud.gke_backup_v1.types.Restore", + "shortName": "get_restore" }, - "description": "Sample for DeleteBackup", - "file": "gkebackup_v1_generated_backup_for_gke_delete_backup_async.py", + "description": "Sample for GetRestore", + "file": "gkebackup_v1_generated_backup_for_gke_get_restore_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteBackup_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestore_async", "segments": [ { - "end": 55, + "end": 51, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 51, "start": 27, "type": "SHORT" }, @@ -948,17 +2826,17 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 52, + "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_restore_async.py" }, { "canonical": true, @@ -967,19 +2845,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_backup", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_restore", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteBackup", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestore", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "DeleteBackup" + "shortName": "GetRestore" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.DeleteBackupRequest" + "type": "google.cloud.gke_backup_v1.types.GetRestoreRequest" }, { "name": "name", @@ -998,22 +2876,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation.Operation", - "shortName": "delete_backup" + "resultType": "google.cloud.gke_backup_v1.types.Restore", + "shortName": "get_restore" }, - "description": "Sample for DeleteBackup", - "file": "gkebackup_v1_generated_backup_for_gke_delete_backup_sync.py", + "description": "Sample for GetRestore", + "file": "gkebackup_v1_generated_backup_for_gke_get_restore_sync_9527929a.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteBackup_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestore_sync", "segments": [ { - "end": 55, + "end": 51, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 51, "start": 27, "type": "SHORT" }, @@ -1028,39 +2906,38 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 52, + "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_delete_backup_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_restore_sync_9527929a.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.delete_restore_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_restore", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestorePlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestore", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "DeleteRestorePlan" + "shortName": "GetRestore" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.DeleteRestorePlanRequest" + "type": "google.cloud.gke_backup_v1.types.GetRestoreRequest" }, { "name": "name", @@ -1079,22 +2956,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "delete_restore_plan" + "resultType": "google.cloud.gke_backup_v1.types.Restore", + "shortName": "get_restore" }, - "description": "Sample for DeleteRestorePlan", - "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_async.py", + "description": "Sample for GetRestore", + "file": "gkebackup_v1_generated_backup_for_gke_get_restore_sync_5d9ab521.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestorePlan_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestore_sync", "segments": [ { - "end": 55, + "end": 51, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 51, "start": 27, "type": "SHORT" }, @@ -1109,38 +2986,39 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 52, + "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_restore_sync_5d9ab521.py" }, { "canonical": true, "clientMethod": { + "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", - "shortName": "BackupForGKEClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_restore_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_volume_backup", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestorePlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeBackup", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "DeleteRestorePlan" + "shortName": "GetVolumeBackup" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.DeleteRestorePlanRequest" + "type": "google.cloud.gke_backup_v1.types.GetVolumeBackupRequest" }, { "name": "name", @@ -1159,22 +3037,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation.Operation", - "shortName": "delete_restore_plan" + "resultType": "google.cloud.gke_backup_v1.types.VolumeBackup", + "shortName": "get_volume_backup" }, - "description": "Sample for DeleteRestorePlan", - "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync.py", + "description": "Sample for GetVolumeBackup", + "file": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestorePlan_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeBackup_async", "segments": [ { - "end": 55, + "end": 51, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 51, "start": 27, "type": "SHORT" }, @@ -1189,39 +3067,38 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 52, + "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_plan_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_async.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.delete_restore", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_volume_backup", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestore", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeBackup", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "DeleteRestore" + "shortName": "GetVolumeBackup" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.DeleteRestoreRequest" + "type": "google.cloud.gke_backup_v1.types.GetVolumeBackupRequest" }, { "name": "name", @@ -1240,22 +3117,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "delete_restore" + "resultType": "google.cloud.gke_backup_v1.types.VolumeBackup", + "shortName": "get_volume_backup" }, - "description": "Sample for DeleteRestore", - "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_async.py", + "description": "Sample for GetVolumeBackup", + "file": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_c8db7aee.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestore_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeBackup_sync", "segments": [ { - "end": 55, + "end": 51, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 51, "start": 27, "type": "SHORT" }, @@ -1270,17 +3147,17 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 52, + "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_c8db7aee.py" }, { "canonical": true, @@ -1289,19 +3166,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.delete_restore", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_volume_backup", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.DeleteRestore", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeBackup", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "DeleteRestore" + "shortName": "GetVolumeBackup" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.DeleteRestoreRequest" + "type": "google.cloud.gke_backup_v1.types.GetVolumeBackupRequest" }, { "name": "name", @@ -1320,22 +3197,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation.Operation", - "shortName": "delete_restore" + "resultType": "google.cloud.gke_backup_v1.types.VolumeBackup", + "shortName": "get_volume_backup" }, - "description": "Sample for DeleteRestore", - "file": "gkebackup_v1_generated_backup_for_gke_delete_restore_sync.py", + "description": "Sample for GetVolumeBackup", + "file": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_315e3ab4.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_DeleteRestore_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeBackup_sync", "segments": [ { - "end": 55, + "end": 51, "start": 27, "type": "FULL" }, { - "end": 55, + "end": 51, "start": 27, "type": "SHORT" }, @@ -1350,17 +3227,17 @@ "type": "REQUEST_INITIALIZATION" }, { - "end": 52, + "end": 48, "start": 46, "type": "REQUEST_EXECUTION" }, { - "end": 56, - "start": 53, + "end": 52, + "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_delete_restore_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync_315e3ab4.py" }, { "canonical": true, @@ -1370,19 +3247,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_backup_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_volume_restore", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackupPlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeRestore", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetBackupPlan" + "shortName": "GetVolumeRestore" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetBackupPlanRequest" + "type": "google.cloud.gke_backup_v1.types.GetVolumeRestoreRequest" }, { "name": "name", @@ -1401,14 +3278,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.BackupPlan", - "shortName": "get_backup_plan" + "resultType": "google.cloud.gke_backup_v1.types.VolumeRestore", + "shortName": "get_volume_restore" }, - "description": "Sample for GetBackupPlan", - "file": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_async.py", + "description": "Sample for GetVolumeRestore", + "file": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackupPlan_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeRestore_async", "segments": [ { "end": 51, @@ -1441,7 +3318,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_async.py" }, { "canonical": true, @@ -1450,19 +3327,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_backup_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_volume_restore", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackupPlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeRestore", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetBackupPlan" + "shortName": "GetVolumeRestore" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetBackupPlanRequest" + "type": "google.cloud.gke_backup_v1.types.GetVolumeRestoreRequest" }, { "name": "name", @@ -1481,14 +3358,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.BackupPlan", - "shortName": "get_backup_plan" + "resultType": "google.cloud.gke_backup_v1.types.VolumeRestore", + "shortName": "get_volume_restore" }, - "description": "Sample for GetBackupPlan", - "file": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync.py", + "description": "Sample for GetVolumeRestore", + "file": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_8da989ef.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackupPlan_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeRestore_sync", "segments": [ { "end": 51, @@ -1521,29 +3398,28 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_backup_plan_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_8da989ef.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_backup", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_volume_restore", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackup", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeRestore", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetBackup" + "shortName": "GetVolumeRestore" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetBackupRequest" + "type": "google.cloud.gke_backup_v1.types.GetVolumeRestoreRequest" }, { "name": "name", @@ -1562,14 +3438,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.Backup", - "shortName": "get_backup" + "resultType": "google.cloud.gke_backup_v1.types.VolumeRestore", + "shortName": "get_volume_restore" }, - "description": "Sample for GetBackup", - "file": "gkebackup_v1_generated_backup_for_gke_get_backup_async.py", + "description": "Sample for GetVolumeRestore", + "file": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_746cfb01.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackup_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeRestore_sync", "segments": [ { "end": 51, @@ -1602,31 +3478,32 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_backup_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync_746cfb01.py" }, { "canonical": true, "clientMethod": { + "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", - "shortName": "BackupForGKEClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_backup", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_backup_plans", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetBackup", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackupPlans", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetBackup" + "shortName": "ListBackupPlans" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetBackupRequest" + "type": "google.cloud.gke_backup_v1.types.ListBackupPlansRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -1642,22 +3519,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.Backup", - "shortName": "get_backup" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupPlansAsyncPager", + "shortName": "list_backup_plans" }, - "description": "Sample for GetBackup", - "file": "gkebackup_v1_generated_backup_for_gke_get_backup_sync.py", + "description": "Sample for ListBackupPlans", + "file": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetBackup_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackupPlans_async", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -1677,37 +3554,36 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_backup_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_async.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_restore_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_backup_plans", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestorePlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackupPlans", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetRestorePlan" + "shortName": "ListBackupPlans" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetRestorePlanRequest" + "type": "google.cloud.gke_backup_v1.types.ListBackupPlansRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -1723,22 +3599,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.RestorePlan", - "shortName": "get_restore_plan" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupPlansPager", + "shortName": "list_backup_plans" }, - "description": "Sample for GetRestorePlan", - "file": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_async.py", + "description": "Sample for ListBackupPlans", + "file": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_60016b65.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestorePlan_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackupPlans_sync", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -1758,12 +3634,12 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_60016b65.py" }, { "canonical": true, @@ -1772,22 +3648,22 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_restore_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_backup_plans", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestorePlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackupPlans", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetRestorePlan" + "shortName": "ListBackupPlans" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetRestorePlanRequest" + "type": "google.cloud.gke_backup_v1.types.ListBackupPlansRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -1803,22 +3679,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.RestorePlan", - "shortName": "get_restore_plan" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupPlansPager", + "shortName": "list_backup_plans" }, - "description": "Sample for GetRestorePlan", - "file": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync.py", + "description": "Sample for ListBackupPlans", + "file": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_5ec6dd54.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestorePlan_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackupPlans_sync", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -1838,12 +3714,12 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_restore_plan_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync_5ec6dd54.py" }, { "canonical": true, @@ -1853,22 +3729,22 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_restore", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_backups", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestore", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackups", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetRestore" + "shortName": "ListBackups" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetRestoreRequest" + "type": "google.cloud.gke_backup_v1.types.ListBackupsRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -1884,22 +3760,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.Restore", - "shortName": "get_restore" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupsAsyncPager", + "shortName": "list_backups" }, - "description": "Sample for GetRestore", - "file": "gkebackup_v1_generated_backup_for_gke_get_restore_async.py", + "description": "Sample for ListBackups", + "file": "gkebackup_v1_generated_backup_for_gke_list_backups_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestore_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackups_async", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -1919,12 +3795,12 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_restore_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_backups_async.py" }, { "canonical": true, @@ -1933,22 +3809,22 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_restore", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_backups", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetRestore", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackups", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetRestore" + "shortName": "ListBackups" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetRestoreRequest" + "type": "google.cloud.gke_backup_v1.types.ListBackupsRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -1964,22 +3840,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.Restore", - "shortName": "get_restore" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupsPager", + "shortName": "list_backups" }, - "description": "Sample for GetRestore", - "file": "gkebackup_v1_generated_backup_for_gke_get_restore_sync.py", + "description": "Sample for ListBackups", + "file": "gkebackup_v1_generated_backup_for_gke_list_backups_sync_7da6881e.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetRestore_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackups_sync", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -1999,37 +3875,36 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_restore_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_backups_sync_7da6881e.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_volume_backup", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_backups", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeBackup", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackups", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetVolumeBackup" + "shortName": "ListBackups" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetVolumeBackupRequest" + "type": "google.cloud.gke_backup_v1.types.ListBackupsRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -2045,22 +3920,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.VolumeBackup", - "shortName": "get_volume_backup" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupsPager", + "shortName": "list_backups" }, - "description": "Sample for GetVolumeBackup", - "file": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_async.py", + "description": "Sample for ListBackups", + "file": "gkebackup_v1_generated_backup_for_gke_list_backups_sync_a7e57cb2.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeBackup_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackups_sync", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -2080,36 +3955,37 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_backups_sync_a7e57cb2.py" }, { "canonical": true, "clientMethod": { + "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", - "shortName": "BackupForGKEClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_volume_backup", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_restore_plans", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeBackup", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestorePlans", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetVolumeBackup" + "shortName": "ListRestorePlans" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetVolumeBackupRequest" + "type": "google.cloud.gke_backup_v1.types.ListRestorePlansRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -2125,22 +4001,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.VolumeBackup", - "shortName": "get_volume_backup" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestorePlansAsyncPager", + "shortName": "list_restore_plans" }, - "description": "Sample for GetVolumeBackup", - "file": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync.py", + "description": "Sample for ListRestorePlans", + "file": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeBackup_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestorePlans_async", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -2160,37 +4036,36 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_volume_backup_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_async.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.get_volume_restore", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_restore_plans", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeRestore", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestorePlans", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetVolumeRestore" + "shortName": "ListRestorePlans" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetVolumeRestoreRequest" + "type": "google.cloud.gke_backup_v1.types.ListRestorePlansRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -2206,22 +4081,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.VolumeRestore", - "shortName": "get_volume_restore" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestorePlansPager", + "shortName": "list_restore_plans" }, - "description": "Sample for GetVolumeRestore", - "file": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_async.py", + "description": "Sample for ListRestorePlans", + "file": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_9e86e9ed.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeRestore_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestorePlans_sync", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -2241,12 +4116,12 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_9e86e9ed.py" }, { "canonical": true, @@ -2255,22 +4130,22 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.get_volume_restore", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_restore_plans", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.GetVolumeRestore", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestorePlans", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "GetVolumeRestore" + "shortName": "ListRestorePlans" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.GetVolumeRestoreRequest" + "type": "google.cloud.gke_backup_v1.types.ListRestorePlansRequest" }, { - "name": "name", + "name": "parent", "type": "str" }, { @@ -2286,22 +4161,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.types.VolumeRestore", - "shortName": "get_volume_restore" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestorePlansPager", + "shortName": "list_restore_plans" }, - "description": "Sample for GetVolumeRestore", - "file": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync.py", + "description": "Sample for ListRestorePlans", + "file": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_ac5c3de5.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_GetVolumeRestore_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestorePlans_sync", "segments": [ { - "end": 51, + "end": 52, "start": 27, "type": "FULL" }, { - "end": 51, + "end": 52, "start": 27, "type": "SHORT" }, @@ -2321,12 +4196,12 @@ "type": "REQUEST_EXECUTION" }, { - "end": 52, + "end": 53, "start": 49, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_get_volume_restore_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync_ac5c3de5.py" }, { "canonical": true, @@ -2336,19 +4211,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_backup_plans", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_restores", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackupPlans", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestores", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListBackupPlans" + "shortName": "ListRestores" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListBackupPlansRequest" + "type": "google.cloud.gke_backup_v1.types.ListRestoresRequest" }, { "name": "parent", @@ -2367,14 +4242,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupPlansAsyncPager", - "shortName": "list_backup_plans" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestoresAsyncPager", + "shortName": "list_restores" }, - "description": "Sample for ListBackupPlans", - "file": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_async.py", + "description": "Sample for ListRestores", + "file": "gkebackup_v1_generated_backup_for_gke_list_restores_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackupPlans_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestores_async", "segments": [ { "end": 52, @@ -2407,7 +4282,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_restores_async.py" }, { "canonical": true, @@ -2416,19 +4291,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_backup_plans", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_restores", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackupPlans", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestores", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListBackupPlans" + "shortName": "ListRestores" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListBackupPlansRequest" + "type": "google.cloud.gke_backup_v1.types.ListRestoresRequest" }, { "name": "parent", @@ -2447,14 +4322,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupPlansPager", - "shortName": "list_backup_plans" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestoresPager", + "shortName": "list_restores" }, - "description": "Sample for ListBackupPlans", - "file": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync.py", + "description": "Sample for ListRestores", + "file": "gkebackup_v1_generated_backup_for_gke_list_restores_sync_c52e2c76.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackupPlans_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestores_sync", "segments": [ { "end": 52, @@ -2487,29 +4362,28 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_backup_plans_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_restores_sync_c52e2c76.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_backups", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_restores", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackups", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestores", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListBackups" + "shortName": "ListRestores" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListBackupsRequest" + "type": "google.cloud.gke_backup_v1.types.ListRestoresRequest" }, { "name": "parent", @@ -2528,14 +4402,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupsAsyncPager", - "shortName": "list_backups" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestoresPager", + "shortName": "list_restores" }, - "description": "Sample for ListBackups", - "file": "gkebackup_v1_generated_backup_for_gke_list_backups_async.py", + "description": "Sample for ListRestores", + "file": "gkebackup_v1_generated_backup_for_gke_list_restores_sync_003c4a18.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackups_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestores_sync", "segments": [ { "end": 52, @@ -2568,28 +4442,29 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_backups_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_restores_sync_003c4a18.py" }, { "canonical": true, "clientMethod": { + "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", - "shortName": "BackupForGKEClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_backups", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_volume_backups", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListBackups", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeBackups", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListBackups" + "shortName": "ListVolumeBackups" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListBackupsRequest" + "type": "google.cloud.gke_backup_v1.types.ListVolumeBackupsRequest" }, { "name": "parent", @@ -2608,14 +4483,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListBackupsPager", - "shortName": "list_backups" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeBackupsAsyncPager", + "shortName": "list_volume_backups" }, - "description": "Sample for ListBackups", - "file": "gkebackup_v1_generated_backup_for_gke_list_backups_sync.py", + "description": "Sample for ListVolumeBackups", + "file": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListBackups_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeBackups_async", "segments": [ { "end": 52, @@ -2648,29 +4523,28 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_backups_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_async.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_restore_plans", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_volume_backups", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestorePlans", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeBackups", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListRestorePlans" + "shortName": "ListVolumeBackups" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListRestorePlansRequest" + "type": "google.cloud.gke_backup_v1.types.ListVolumeBackupsRequest" }, { "name": "parent", @@ -2689,14 +4563,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestorePlansAsyncPager", - "shortName": "list_restore_plans" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeBackupsPager", + "shortName": "list_volume_backups" }, - "description": "Sample for ListRestorePlans", - "file": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_async.py", + "description": "Sample for ListVolumeBackups", + "file": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_66d26f94.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestorePlans_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeBackups_sync", "segments": [ { "end": 52, @@ -2729,7 +4603,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_66d26f94.py" }, { "canonical": true, @@ -2738,19 +4612,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_restore_plans", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_volume_backups", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestorePlans", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeBackups", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListRestorePlans" + "shortName": "ListVolumeBackups" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListRestorePlansRequest" + "type": "google.cloud.gke_backup_v1.types.ListVolumeBackupsRequest" }, { "name": "parent", @@ -2769,14 +4643,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestorePlansPager", - "shortName": "list_restore_plans" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeBackupsPager", + "shortName": "list_volume_backups" }, - "description": "Sample for ListRestorePlans", - "file": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync.py", + "description": "Sample for ListVolumeBackups", + "file": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_b686a40a.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestorePlans_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeBackups_sync", "segments": [ { "end": 52, @@ -2809,7 +4683,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_restore_plans_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync_b686a40a.py" }, { "canonical": true, @@ -2819,19 +4693,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_restores", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_volume_restores", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestores", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeRestores", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListRestores" + "shortName": "ListVolumeRestores" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListRestoresRequest" + "type": "google.cloud.gke_backup_v1.types.ListVolumeRestoresRequest" }, { "name": "parent", @@ -2850,14 +4724,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestoresAsyncPager", - "shortName": "list_restores" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeRestoresAsyncPager", + "shortName": "list_volume_restores" }, - "description": "Sample for ListRestores", - "file": "gkebackup_v1_generated_backup_for_gke_list_restores_async.py", + "description": "Sample for ListVolumeRestores", + "file": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestores_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeRestores_async", "segments": [ { "end": 52, @@ -2890,7 +4764,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_restores_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_async.py" }, { "canonical": true, @@ -2899,19 +4773,19 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_restores", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_volume_restores", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListRestores", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeRestores", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListRestores" + "shortName": "ListVolumeRestores" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListRestoresRequest" + "type": "google.cloud.gke_backup_v1.types.ListVolumeRestoresRequest" }, { "name": "parent", @@ -2930,14 +4804,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListRestoresPager", - "shortName": "list_restores" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeRestoresPager", + "shortName": "list_volume_restores" }, - "description": "Sample for ListRestores", - "file": "gkebackup_v1_generated_backup_for_gke_list_restores_sync.py", + "description": "Sample for ListVolumeRestores", + "file": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_96c127d6.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListRestores_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeRestores_sync", "segments": [ { "end": 52, @@ -2970,29 +4844,28 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_restores_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_96c127d6.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_volume_backups", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_volume_restores", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeBackups", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeRestores", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListVolumeBackups" + "shortName": "ListVolumeRestores" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListVolumeBackupsRequest" + "type": "google.cloud.gke_backup_v1.types.ListVolumeRestoresRequest" }, { "name": "parent", @@ -3011,14 +4884,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeBackupsAsyncPager", - "shortName": "list_volume_backups" + "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeRestoresPager", + "shortName": "list_volume_restores" }, - "description": "Sample for ListVolumeBackups", - "file": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_async.py", + "description": "Sample for ListVolumeRestores", + "file": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_e6df2c15.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeBackups_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeRestores_sync", "segments": [ { "end": 52, @@ -3051,32 +4924,37 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync_e6df2c15.py" }, { "canonical": true, "clientMethod": { + "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", - "shortName": "BackupForGKEClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_volume_backups", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.update_backup_plan", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeBackups", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateBackupPlan", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListVolumeBackups" + "shortName": "UpdateBackupPlan" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListVolumeBackupsRequest" + "type": "google.cloud.gke_backup_v1.types.UpdateBackupPlanRequest" }, { - "name": "parent", - "type": "str" + "name": "backup_plan", + "type": "google.cloud.gke_backup_v1.types.BackupPlan" + }, + { + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" }, { "name": "retry", @@ -3091,22 +4969,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeBackupsPager", - "shortName": "list_volume_backups" + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "update_backup_plan" }, - "description": "Sample for ListVolumeBackups", - "file": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync.py", + "description": "Sample for UpdateBackupPlan", + "file": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeBackups_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackupPlan_async", "segments": [ { - "end": 52, + "end": 58, "start": 27, "type": "FULL" }, { - "end": 52, + "end": 58, "start": 27, "type": "SHORT" }, @@ -3116,48 +4994,51 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 45, + "end": 48, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 48, - "start": 46, + "end": 55, + "start": 49, "type": "REQUEST_EXECUTION" }, { - "end": 53, - "start": 49, + "end": 59, + "start": 56, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_volume_backups_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_async.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.list_volume_restores", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.update_backup_plan", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeRestores", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateBackupPlan", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListVolumeRestores" + "shortName": "UpdateBackupPlan" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListVolumeRestoresRequest" + "type": "google.cloud.gke_backup_v1.types.UpdateBackupPlanRequest" + }, + { + "name": "backup_plan", + "type": "google.cloud.gke_backup_v1.types.BackupPlan" }, { - "name": "parent", - "type": "str" + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" }, { "name": "retry", @@ -3172,22 +5053,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeRestoresAsyncPager", - "shortName": "list_volume_restores" + "resultType": "google.api_core.operation.Operation", + "shortName": "update_backup_plan" }, - "description": "Sample for ListVolumeRestores", - "file": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_async.py", + "description": "Sample for UpdateBackupPlan", + "file": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_240d1e05.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeRestores_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackupPlan_sync", "segments": [ { - "end": 52, + "end": 58, "start": 27, "type": "FULL" }, { - "end": 52, + "end": 58, "start": 27, "type": "SHORT" }, @@ -3197,22 +5078,22 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 45, + "end": 48, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 48, - "start": 46, + "end": 55, + "start": 49, "type": "REQUEST_EXECUTION" }, { - "end": 53, - "start": 49, + "end": 59, + "start": 56, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_240d1e05.py" }, { "canonical": true, @@ -3221,23 +5102,27 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.list_volume_restores", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.update_backup_plan", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.ListVolumeRestores", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateBackupPlan", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "ListVolumeRestores" + "shortName": "UpdateBackupPlan" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.ListVolumeRestoresRequest" + "type": "google.cloud.gke_backup_v1.types.UpdateBackupPlanRequest" }, { - "name": "parent", - "type": "str" + "name": "backup_plan", + "type": "google.cloud.gke_backup_v1.types.BackupPlan" + }, + { + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" }, { "name": "retry", @@ -3252,22 +5137,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.cloud.gke_backup_v1.services.backup_for_gke.pagers.ListVolumeRestoresPager", - "shortName": "list_volume_restores" + "resultType": "google.api_core.operation.Operation", + "shortName": "update_backup_plan" }, - "description": "Sample for ListVolumeRestores", - "file": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync.py", + "description": "Sample for UpdateBackupPlan", + "file": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_e9cd4e74.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_ListVolumeRestores_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackupPlan_sync", "segments": [ { - "end": 52, + "end": 58, "start": 27, "type": "FULL" }, { - "end": 52, + "end": 58, "start": 27, "type": "SHORT" }, @@ -3277,22 +5162,22 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 45, + "end": 48, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 48, - "start": 46, + "end": 55, + "start": 49, "type": "REQUEST_EXECUTION" }, { - "end": 53, - "start": 49, + "end": 59, + "start": 56, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_list_volume_restores_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync_e9cd4e74.py" }, { "canonical": true, @@ -3302,23 +5187,23 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.update_backup_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.update_backup", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateBackupPlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateBackup", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "UpdateBackupPlan" + "shortName": "UpdateBackup" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.UpdateBackupPlanRequest" + "type": "google.cloud.gke_backup_v1.types.UpdateBackupRequest" }, { - "name": "backup_plan", - "type": "google.cloud.gke_backup_v1.types.BackupPlan" + "name": "backup", + "type": "google.cloud.gke_backup_v1.types.Backup" }, { "name": "update_mask", @@ -3338,13 +5223,13 @@ } ], "resultType": "google.api_core.operation_async.AsyncOperation", - "shortName": "update_backup_plan" + "shortName": "update_backup" }, - "description": "Sample for UpdateBackupPlan", - "file": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_async.py", + "description": "Sample for UpdateBackup", + "file": "gkebackup_v1_generated_backup_for_gke_update_backup_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackupPlan_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackup_async", "segments": [ { "end": 58, @@ -3377,7 +5262,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_backup_async.py" }, { "canonical": true, @@ -3386,23 +5271,23 @@ "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.update_backup_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.update_backup", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateBackupPlan", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateBackup", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "UpdateBackupPlan" + "shortName": "UpdateBackup" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.UpdateBackupPlanRequest" + "type": "google.cloud.gke_backup_v1.types.UpdateBackupRequest" }, { - "name": "backup_plan", - "type": "google.cloud.gke_backup_v1.types.BackupPlan" + "name": "backup", + "type": "google.cloud.gke_backup_v1.types.Backup" }, { "name": "update_mask", @@ -3422,13 +5307,13 @@ } ], "resultType": "google.api_core.operation.Operation", - "shortName": "update_backup_plan" + "shortName": "update_backup" }, - "description": "Sample for UpdateBackupPlan", - "file": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync.py", + "description": "Sample for UpdateBackup", + "file": "gkebackup_v1_generated_backup_for_gke_update_backup_sync_701ec3bb.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackupPlan_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackup_sync", "segments": [ { "end": 58, @@ -3461,17 +5346,16 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_update_backup_plan_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_backup_sync_701ec3bb.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.update_backup", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.update_backup", "method": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateBackup", "service": { @@ -3506,14 +5390,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation_async.AsyncOperation", + "resultType": "google.api_core.operation.Operation", "shortName": "update_backup" }, "description": "Sample for UpdateBackup", - "file": "gkebackup_v1_generated_backup_for_gke_update_backup_async.py", + "file": "gkebackup_v1_generated_backup_for_gke_update_backup_sync_c44e40c5.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackup_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackup_sync", "segments": [ { "end": 58, @@ -3546,32 +5430,33 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_update_backup_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_backup_sync_c44e40c5.py" }, { "canonical": true, "clientMethod": { + "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", - "shortName": "BackupForGKEClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", + "shortName": "BackupForGKEAsyncClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.update_backup", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.update_restore_plan", "method": { - "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateBackup", + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateRestorePlan", "service": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE", "shortName": "BackupForGKE" }, - "shortName": "UpdateBackup" + "shortName": "UpdateRestorePlan" }, "parameters": [ { "name": "request", - "type": "google.cloud.gke_backup_v1.types.UpdateBackupRequest" + "type": "google.cloud.gke_backup_v1.types.UpdateRestorePlanRequest" }, { - "name": "backup", - "type": "google.cloud.gke_backup_v1.types.Backup" + "name": "restore_plan", + "type": "google.cloud.gke_backup_v1.types.RestorePlan" }, { "name": "update_mask", @@ -3590,22 +5475,22 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation.Operation", - "shortName": "update_backup" + "resultType": "google.api_core.operation_async.AsyncOperation", + "shortName": "update_restore_plan" }, - "description": "Sample for UpdateBackup", - "file": "gkebackup_v1_generated_backup_for_gke_update_backup_sync.py", + "description": "Sample for UpdateRestorePlan", + "file": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_async.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateBackup_sync", + "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateRestorePlan_async", "segments": [ { - "end": 58, + "end": 60, "start": 27, "type": "FULL" }, { - "end": 58, + "end": 60, "start": 27, "type": "SHORT" }, @@ -3615,32 +5500,31 @@ "type": "CLIENT_INITIALIZATION" }, { - "end": 48, + "end": 50, "start": 41, "type": "REQUEST_INITIALIZATION" }, { - "end": 55, - "start": 49, + "end": 57, + "start": 51, "type": "REQUEST_EXECUTION" }, { - "end": 59, - "start": 56, + "end": 61, + "start": 58, "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_update_backup_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_async.py" }, { "canonical": true, "clientMethod": { - "async": true, "client": { - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient", - "shortName": "BackupForGKEAsyncClient" + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" }, - "fullName": "google.cloud.gke_backup_v1.BackupForGKEAsyncClient.update_restore_plan", + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.update_restore_plan", "method": { "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateRestorePlan", "service": { @@ -3675,14 +5559,14 @@ "type": "Sequence[Tuple[str, str]" } ], - "resultType": "google.api_core.operation_async.AsyncOperation", + "resultType": "google.api_core.operation.Operation", "shortName": "update_restore_plan" }, "description": "Sample for UpdateRestorePlan", - "file": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_async.py", + "file": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_b115a29d.py", "language": "PYTHON", "origin": "API_DEFINITION", - "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateRestorePlan_async", + "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateRestorePlan_sync", "segments": [ { "end": 60, @@ -3715,7 +5599,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_async.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_b115a29d.py" }, { "canonical": true, @@ -3763,7 +5647,7 @@ "shortName": "update_restore_plan" }, "description": "Sample for UpdateRestorePlan", - "file": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync.py", + "file": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_a36705f8.py", "language": "PYTHON", "origin": "API_DEFINITION", "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateRestorePlan_sync", @@ -3799,7 +5683,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_restore_plan_sync_a36705f8.py" }, { "canonical": true, @@ -3932,7 +5816,91 @@ "shortName": "update_restore" }, "description": "Sample for UpdateRestore", - "file": "gkebackup_v1_generated_backup_for_gke_update_restore_sync.py", + "file": "gkebackup_v1_generated_backup_for_gke_update_restore_sync_f27381f8.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateRestore_sync", + "segments": [ + { + "end": 58, + "start": 27, + "type": "FULL" + }, + { + "end": 58, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 48, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 55, + "start": 49, + "type": "REQUEST_EXECUTION" + }, + { + "end": 59, + "start": 56, + "type": "RESPONSE_HANDLING" + } + ], + "title": "gkebackup_v1_generated_backup_for_gke_update_restore_sync_f27381f8.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient", + "shortName": "BackupForGKEClient" + }, + "fullName": "google.cloud.gke_backup_v1.BackupForGKEClient.update_restore", + "method": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE.UpdateRestore", + "service": { + "fullName": "google.cloud.gkebackup.v1.BackupForGKE", + "shortName": "BackupForGKE" + }, + "shortName": "UpdateRestore" + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.gke_backup_v1.types.UpdateRestoreRequest" + }, + { + "name": "restore", + "type": "google.cloud.gke_backup_v1.types.Restore" + }, + { + "name": "update_mask", + "type": "google.protobuf.field_mask_pb2.FieldMask" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.api_core.operation.Operation", + "shortName": "update_restore" + }, + "description": "Sample for UpdateRestore", + "file": "gkebackup_v1_generated_backup_for_gke_update_restore_sync_01ce4e95.py", "language": "PYTHON", "origin": "API_DEFINITION", "regionTag": "gkebackup_v1_generated_BackupForGKE_UpdateRestore_sync", @@ -3968,7 +5936,7 @@ "type": "RESPONSE_HANDLING" } ], - "title": "gkebackup_v1_generated_backup_for_gke_update_restore_sync.py" + "title": "gkebackup_v1_generated_backup_for_gke_update_restore_sync_01ce4e95.py" } ] } diff --git a/setup.py b/setup.py index df8ab35..4fb6d32 100644 --- a/setup.py +++ b/setup.py @@ -24,9 +24,9 @@ version = "0.1.1" release_status = "Development Status :: 4 - Beta" dependencies = [ - "google-api-core[grpc] >= 2.8.0, <3.0.0dev", + "google-api-core[grpc] >= 1.33.1, <3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,!=2.5.*,!=2.6.*,!=2.7.*", "proto-plus >= 1.22.0, <2.0.0dev", - "protobuf >= 3.19.0, <5.0.0dev", + "protobuf >= 3.20.1, <5.0.0dev", ] url = "https://github.com/googleapis/python-gke-backup" diff --git a/testing/constraints-3.7.txt b/testing/constraints-3.7.txt index 807e5ff..12cb23a 100644 --- a/testing/constraints-3.7.txt +++ b/testing/constraints-3.7.txt @@ -4,6 +4,6 @@ # Pin the version to the lower bound. # e.g., if setup.py has "google-cloud-foo >= 1.14.0, < 2.0.0dev", # Then this file should have google-cloud-foo==1.14.0 -google-api-core==2.8.0 +google-api-core==1.33.1 proto-plus==1.22.0 -protobuf==3.19.0 +protobuf==3.20.1 diff --git a/tests/unit/gapic/gke_backup_v1/test_backup_for_gke.py b/tests/unit/gapic/gke_backup_v1/test_backup_for_gke.py index 5130473..a44bb9a 100644 --- a/tests/unit/gapic/gke_backup_v1/test_backup_for_gke.py +++ b/tests/unit/gapic/gke_backup_v1/test_backup_for_gke.py @@ -24,10 +24,17 @@ import grpc from grpc.experimental import aio +from collections.abc import Iterable +from google.protobuf import json_format +import json import math import pytest from proto.marshal.rules.dates import DurationRule, TimestampRule from proto.marshal.rules import wrappers +from requests import Response +from requests import Request, PreparedRequest +from requests.sessions import Session +from google.protobuf import json_format from google.api_core import client_options from google.api_core import exceptions as core_exceptions @@ -109,6 +116,7 @@ def test__get_default_mtls_endpoint(): [ (BackupForGKEClient, "grpc"), (BackupForGKEAsyncClient, "grpc_asyncio"), + (BackupForGKEClient, "rest"), ], ) def test_backup_for_gke_client_from_service_account_info(client_class, transport_name): @@ -122,7 +130,11 @@ def test_backup_for_gke_client_from_service_account_info(client_class, transport assert client.transport._credentials == creds assert isinstance(client, client_class) - assert client.transport._host == ("gkebackup.googleapis.com:443") + assert client.transport._host == ( + "gkebackup.googleapis.com:443" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://gkebackup.googleapis.com" + ) @pytest.mark.parametrize( @@ -130,6 +142,7 @@ def test_backup_for_gke_client_from_service_account_info(client_class, transport [ (transports.BackupForGKEGrpcTransport, "grpc"), (transports.BackupForGKEGrpcAsyncIOTransport, "grpc_asyncio"), + (transports.BackupForGKERestTransport, "rest"), ], ) def test_backup_for_gke_client_service_account_always_use_jwt( @@ -155,6 +168,7 @@ def test_backup_for_gke_client_service_account_always_use_jwt( [ (BackupForGKEClient, "grpc"), (BackupForGKEAsyncClient, "grpc_asyncio"), + (BackupForGKEClient, "rest"), ], ) def test_backup_for_gke_client_from_service_account_file(client_class, transport_name): @@ -175,13 +189,18 @@ def test_backup_for_gke_client_from_service_account_file(client_class, transport assert client.transport._credentials == creds assert isinstance(client, client_class) - assert client.transport._host == ("gkebackup.googleapis.com:443") + assert client.transport._host == ( + "gkebackup.googleapis.com:443" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://gkebackup.googleapis.com" + ) def test_backup_for_gke_client_get_transport_class(): transport = BackupForGKEClient.get_transport_class() available_transports = [ transports.BackupForGKEGrpcTransport, + transports.BackupForGKERestTransport, ] assert transport in available_transports @@ -198,6 +217,7 @@ def test_backup_for_gke_client_get_transport_class(): transports.BackupForGKEGrpcAsyncIOTransport, "grpc_asyncio", ), + (BackupForGKEClient, transports.BackupForGKERestTransport, "rest"), ], ) @mock.patch.object( @@ -341,6 +361,8 @@ def test_backup_for_gke_client_client_options( "grpc_asyncio", "false", ), + (BackupForGKEClient, transports.BackupForGKERestTransport, "rest", "true"), + (BackupForGKEClient, transports.BackupForGKERestTransport, "rest", "false"), ], ) @mock.patch.object( @@ -534,6 +556,7 @@ def test_backup_for_gke_client_get_mtls_endpoint_and_cert_source(client_class): transports.BackupForGKEGrpcAsyncIOTransport, "grpc_asyncio", ), + (BackupForGKEClient, transports.BackupForGKERestTransport, "rest"), ], ) def test_backup_for_gke_client_client_options_scopes( @@ -574,6 +597,7 @@ def test_backup_for_gke_client_client_options_scopes( "grpc_asyncio", grpc_helpers_async, ), + (BackupForGKEClient, transports.BackupForGKERestTransport, "rest", None), ], ) def test_backup_for_gke_client_client_options_credentials_file( @@ -7841,215 +7865,8046 @@ async def test_get_volume_restore_flattened_error_async(): ) -def test_credentials_transport_error(): - # It is an error to provide credentials and a transport instance. - transport = transports.BackupForGKEGrpcTransport( +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.CreateBackupPlanRequest, + dict, + ], +) +def test_create_backup_plan_rest(request_type): + client = BackupForGKEClient( credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): - client = BackupForGKEClient( - credentials=ga_credentials.AnonymousCredentials(), - transport=transport, + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request_init["backup_plan"] = { + "name": "name_value", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "cluster": "cluster_value", + "retention_policy": { + "backup_delete_lock_days": 2400, + "backup_retain_days": 1896, + "locked": True, + }, + "labels": {}, + "backup_schedule": {"cron_schedule": "cron_schedule_value", "paused": True}, + "etag": "etag_value", + "deactivated": True, + "backup_config": { + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "include_volume_data": True, + "include_secrets": True, + "encryption_key": { + "gcp_kms_encryption_key": "gcp_kms_encryption_key_value" + }, + }, + "protected_pod_count": 2036, + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.create_backup_plan(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_create_backup_plan_rest_required_fields( + request_type=gkebackup.CreateBackupPlanRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request_init["backup_plan_id"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, ) + ) - # It is an error to provide a credentials file and a transport instance. - transport = transports.BackupForGKEGrpcTransport( + # verify fields with default values are dropped + assert "backupPlanId" not in jsonified_request + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_backup_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + assert "backupPlanId" in jsonified_request + assert jsonified_request["backupPlanId"] == request_init["backup_plan_id"] + + jsonified_request["parent"] = "parent_value" + jsonified_request["backupPlanId"] = "backup_plan_id_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_backup_plan._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("backup_plan_id",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + assert "backupPlanId" in jsonified_request + assert jsonified_request["backupPlanId"] == "backup_plan_id_value" + + client = BackupForGKEClient( credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): - client = BackupForGKEClient( - client_options={"credentials_file": "credentials.json"}, - transport=transport, + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.create_backup_plan(request) + + expected_params = [ + ( + "backupPlanId", + "", + ), + ] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_backup_plan_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_backup_plan._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("backupPlanId",)) + & set( + ( + "parent", + "backupPlan", + "backupPlanId", + ) ) + ) - # It is an error to provide an api_key and a transport instance. - transport = transports.BackupForGKEGrpcTransport( + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_backup_plan_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), ) - options = client_options.ClientOptions() - options.api_key = "api_key" - with pytest.raises(ValueError): - client = BackupForGKEClient( - client_options=options, - transport=transport, + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_create_backup_plan" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_create_backup_plan" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.CreateBackupPlanRequest.pb( + gkebackup.CreateBackupPlanRequest() ) - - # It is an error to provide an api_key and a credential. - options = mock.Mock() - options.api_key = "api_key" - with pytest.raises(ValueError): - client = BackupForGKEClient( - client_options=options, credentials=ga_credentials.AnonymousCredentials() + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() ) - # It is an error to provide scopes and a transport instance. - transport = transports.BackupForGKEGrpcTransport( - credentials=ga_credentials.AnonymousCredentials(), - ) - with pytest.raises(ValueError): - client = BackupForGKEClient( - client_options={"scopes": ["1", "2"]}, - transport=transport, + request = gkebackup.CreateBackupPlanRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.create_backup_plan( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], ) + pre.assert_called_once() + post.assert_called_once() -def test_transport_instance(): - # A client may be instantiated with a custom transport instance. - transport = transports.BackupForGKEGrpcTransport( + +def test_create_backup_plan_rest_bad_request( + transport: str = "rest", request_type=gkebackup.CreateBackupPlanRequest +): + client = BackupForGKEClient( credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - client = BackupForGKEClient(transport=transport) - assert client.transport is transport + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request_init["backup_plan"] = { + "name": "name_value", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "cluster": "cluster_value", + "retention_policy": { + "backup_delete_lock_days": 2400, + "backup_retain_days": 1896, + "locked": True, + }, + "labels": {}, + "backup_schedule": {"cron_schedule": "cron_schedule_value", "paused": True}, + "etag": "etag_value", + "deactivated": True, + "backup_config": { + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "include_volume_data": True, + "include_secrets": True, + "encryption_key": { + "gcp_kms_encryption_key": "gcp_kms_encryption_key_value" + }, + }, + "protected_pod_count": 2036, + } + request = request_type(**request_init) -def test_transport_get_channel(): - # A client may be instantiated with a custom transport instance. - transport = transports.BackupForGKEGrpcTransport( + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.create_backup_plan(request) + + +def test_create_backup_plan_rest_flattened(): + client = BackupForGKEClient( credentials=ga_credentials.AnonymousCredentials(), + transport="rest", ) - channel = transport.grpc_channel - assert channel - transport = transports.BackupForGKEGrpcAsyncIOTransport( + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + backup_plan=gcg_backup_plan.BackupPlan(name="name_value"), + backup_plan_id="backup_plan_id_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.create_backup_plan(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*}/backupPlans" + % client.transport._host, + args[1], + ) + + +def test_create_backup_plan_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) - channel = transport.grpc_channel - assert channel + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_backup_plan( + gkebackup.CreateBackupPlanRequest(), + parent="parent_value", + backup_plan=gcg_backup_plan.BackupPlan(name="name_value"), + backup_plan_id="backup_plan_id_value", + ) -@pytest.mark.parametrize( - "transport_class", - [ - transports.BackupForGKEGrpcTransport, - transports.BackupForGKEGrpcAsyncIOTransport, - ], -) -def test_transport_adc(transport_class): - # Test default credentials are used if not provided. - with mock.patch.object(google.auth, "default") as adc: - adc.return_value = (ga_credentials.AnonymousCredentials(), None) - transport_class() - adc.assert_called_once() + +def test_create_backup_plan_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) @pytest.mark.parametrize( - "transport_name", + "request_type", [ - "grpc", + gkebackup.ListBackupPlansRequest, + dict, ], ) -def test_transport_kind(transport_name): - transport = BackupForGKEClient.get_transport_class(transport_name)( - credentials=ga_credentials.AnonymousCredentials(), - ) - assert transport.kind == transport_name - - -def test_transport_grpc_default(): - # A client should use the gRPC transport by default. +def test_list_backup_plans_rest(request_type): client = BackupForGKEClient( credentials=ga_credentials.AnonymousCredentials(), - ) - assert isinstance( - client.transport, - transports.BackupForGKEGrpcTransport, + transport="rest", ) + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) -def test_backup_for_gke_base_transport_error(): - # Passing both a credentials object and credentials_file should raise an error - with pytest.raises(core_exceptions.DuplicateCredentialArgs): - transport = transports.BackupForGKETransport( - credentials=ga_credentials.AnonymousCredentials(), - credentials_file="credentials.json", + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListBackupPlansResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], ) + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListBackupPlansResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) -def test_backup_for_gke_base_transport(): - # Instantiate the base transport. - with mock.patch( - "google.cloud.gke_backup_v1.services.backup_for_gke.transports.BackupForGKETransport.__init__" - ) as Transport: - Transport.return_value = None - transport = transports.BackupForGKETransport( - credentials=ga_credentials.AnonymousCredentials(), - ) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_backup_plans(request) - # Every method on the transport should just blindly - # raise NotImplementedError. - methods = ( - "create_backup_plan", - "list_backup_plans", - "get_backup_plan", - "update_backup_plan", - "delete_backup_plan", - "create_backup", - "list_backups", - "get_backup", - "update_backup", - "delete_backup", - "list_volume_backups", - "get_volume_backup", - "create_restore_plan", - "list_restore_plans", - "get_restore_plan", - "update_restore_plan", - "delete_restore_plan", - "create_restore", - "list_restores", - "get_restore", - "update_restore", - "delete_restore", - "list_volume_restores", - "get_volume_restore", + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListBackupPlansPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] + + +def test_list_backup_plans_rest_required_fields( + request_type=gkebackup.ListBackupPlansRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) ) - for method in methods: - with pytest.raises(NotImplementedError): - getattr(transport, method)(request=object()) - with pytest.raises(NotImplementedError): - transport.close() + # verify fields with default values are dropped - # Additionally, the LRO client (a property) should - # also raise NotImplementedError - with pytest.raises(NotImplementedError): - transport.operations_client + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_backup_plans._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) - # Catch all for all remaining methods and properties - remainder = [ - "kind", - ] - for r in remainder: - with pytest.raises(NotImplementedError): - getattr(transport, r)() + # verify required fields with default values are now present + jsonified_request["parent"] = "parent_value" -def test_backup_for_gke_base_transport_with_credentials_file(): - # Instantiate the base transport with a credentials file - with mock.patch.object( - google.auth, "load_credentials_from_file", autospec=True - ) as load_creds, mock.patch( - "google.cloud.gke_backup_v1.services.backup_for_gke.transports.BackupForGKETransport._prep_wrapped_messages" - ) as Transport: - Transport.return_value = None - load_creds.return_value = (ga_credentials.AnonymousCredentials(), None) - transport = transports.BackupForGKETransport( - credentials_file="credentials.json", - quota_project_id="octopus", + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_backup_plans._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "order_by", + "page_size", + "page_token", ) - load_creds.assert_called_once_with( - "credentials.json", - scopes=None, - default_scopes=("https://www.googleapis.com/auth/cloud-platform",), - quota_project_id="octopus", + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListBackupPlansResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = gkebackup.ListBackupPlansResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_backup_plans(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_backup_plans_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_backup_plans._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + ) ) + & set(("parent",)) + ) -def test_backup_for_gke_base_transport_with_adc(): - # Test the default credentials are used if credentials and credentials_file are None. - with mock.patch.object(google.auth, "default", autospec=True) as adc, mock.patch( - "google.cloud.gke_backup_v1.services.backup_for_gke.transports.BackupForGKETransport._prep_wrapped_messages" - ) as Transport: +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_backup_plans_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_list_backup_plans" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_list_backup_plans" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.ListBackupPlansRequest.pb( + gkebackup.ListBackupPlansRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = gkebackup.ListBackupPlansResponse.to_json( + gkebackup.ListBackupPlansResponse() + ) + + request = gkebackup.ListBackupPlansRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gkebackup.ListBackupPlansResponse() + + client.list_backup_plans( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_backup_plans_rest_bad_request( + transport: str = "rest", request_type=gkebackup.ListBackupPlansRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.list_backup_plans(request) + + +def test_list_backup_plans_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListBackupPlansResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListBackupPlansResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_backup_plans(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*}/backupPlans" + % client.transport._host, + args[1], + ) + + +def test_list_backup_plans_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_backup_plans( + gkebackup.ListBackupPlansRequest(), + parent="parent_value", + ) + + +def test_list_backup_plans_rest_pager(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + gkebackup.ListBackupPlansResponse( + backup_plans=[ + backup_plan.BackupPlan(), + backup_plan.BackupPlan(), + backup_plan.BackupPlan(), + ], + next_page_token="abc", + ), + gkebackup.ListBackupPlansResponse( + backup_plans=[], + next_page_token="def", + ), + gkebackup.ListBackupPlansResponse( + backup_plans=[ + backup_plan.BackupPlan(), + ], + next_page_token="ghi", + ), + gkebackup.ListBackupPlansResponse( + backup_plans=[ + backup_plan.BackupPlan(), + backup_plan.BackupPlan(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple(gkebackup.ListBackupPlansResponse.to_json(x) for x in response) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = {"parent": "projects/sample1/locations/sample2"} + + pager = client.list_backup_plans(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, backup_plan.BackupPlan) for i in results) + + pages = list(client.list_backup_plans(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.GetBackupPlanRequest, + dict, + ], +) +def test_get_backup_plan_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/backupPlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = backup_plan.BackupPlan( + name="name_value", + uid="uid_value", + description="description_value", + cluster="cluster_value", + etag="etag_value", + deactivated=True, + protected_pod_count=2036, + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = backup_plan.BackupPlan.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.get_backup_plan(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, backup_plan.BackupPlan) + assert response.name == "name_value" + assert response.uid == "uid_value" + assert response.description == "description_value" + assert response.cluster == "cluster_value" + assert response.etag == "etag_value" + assert response.deactivated is True + assert response.protected_pod_count == 2036 + + +def test_get_backup_plan_rest_required_fields( + request_type=gkebackup.GetBackupPlanRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_backup_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_backup_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = backup_plan.BackupPlan() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = backup_plan.BackupPlan.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.get_backup_plan(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_backup_plan_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_backup_plan._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_backup_plan_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_get_backup_plan" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_get_backup_plan" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.GetBackupPlanRequest.pb(gkebackup.GetBackupPlanRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = backup_plan.BackupPlan.to_json( + backup_plan.BackupPlan() + ) + + request = gkebackup.GetBackupPlanRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = backup_plan.BackupPlan() + + client.get_backup_plan( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_get_backup_plan_rest_bad_request( + transport: str = "rest", request_type=gkebackup.GetBackupPlanRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/backupPlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.get_backup_plan(request) + + +def test_get_backup_plan_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = backup_plan.BackupPlan() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = backup_plan.BackupPlan.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.get_backup_plan(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/backupPlans/*}" + % client.transport._host, + args[1], + ) + + +def test_get_backup_plan_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_backup_plan( + gkebackup.GetBackupPlanRequest(), + name="name_value", + ) + + +def test_get_backup_plan_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.UpdateBackupPlanRequest, + dict, + ], +) +def test_update_backup_plan_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "backup_plan": { + "name": "projects/sample1/locations/sample2/backupPlans/sample3" + } + } + request_init["backup_plan"] = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "cluster": "cluster_value", + "retention_policy": { + "backup_delete_lock_days": 2400, + "backup_retain_days": 1896, + "locked": True, + }, + "labels": {}, + "backup_schedule": {"cron_schedule": "cron_schedule_value", "paused": True}, + "etag": "etag_value", + "deactivated": True, + "backup_config": { + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "include_volume_data": True, + "include_secrets": True, + "encryption_key": { + "gcp_kms_encryption_key": "gcp_kms_encryption_key_value" + }, + }, + "protected_pod_count": 2036, + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.update_backup_plan(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_update_backup_plan_rest_required_fields( + request_type=gkebackup.UpdateBackupPlanRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_backup_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_backup_plan._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("update_mask",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "patch", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.update_backup_plan(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_update_backup_plan_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.update_backup_plan._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("backupPlan",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_backup_plan_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_update_backup_plan" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_update_backup_plan" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.UpdateBackupPlanRequest.pb( + gkebackup.UpdateBackupPlanRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.UpdateBackupPlanRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.update_backup_plan( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_update_backup_plan_rest_bad_request( + transport: str = "rest", request_type=gkebackup.UpdateBackupPlanRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "backup_plan": { + "name": "projects/sample1/locations/sample2/backupPlans/sample3" + } + } + request_init["backup_plan"] = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "cluster": "cluster_value", + "retention_policy": { + "backup_delete_lock_days": 2400, + "backup_retain_days": 1896, + "locked": True, + }, + "labels": {}, + "backup_schedule": {"cron_schedule": "cron_schedule_value", "paused": True}, + "etag": "etag_value", + "deactivated": True, + "backup_config": { + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "include_volume_data": True, + "include_secrets": True, + "encryption_key": { + "gcp_kms_encryption_key": "gcp_kms_encryption_key_value" + }, + }, + "protected_pod_count": 2036, + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.update_backup_plan(request) + + +def test_update_backup_plan_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "backup_plan": { + "name": "projects/sample1/locations/sample2/backupPlans/sample3" + } + } + + # get truthy value for each flattened field + mock_args = dict( + backup_plan=gcg_backup_plan.BackupPlan(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.update_backup_plan(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{backup_plan.name=projects/*/locations/*/backupPlans/*}" + % client.transport._host, + args[1], + ) + + +def test_update_backup_plan_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_backup_plan( + gkebackup.UpdateBackupPlanRequest(), + backup_plan=gcg_backup_plan.BackupPlan(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_update_backup_plan_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.DeleteBackupPlanRequest, + dict, + ], +) +def test_delete_backup_plan_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/backupPlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.delete_backup_plan(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_delete_backup_plan_rest_required_fields( + request_type=gkebackup.DeleteBackupPlanRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_backup_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_backup_plan._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("etag",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "delete", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.delete_backup_plan(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_backup_plan_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_backup_plan._get_unset_required_fields({}) + assert set(unset_fields) == (set(("etag",)) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_backup_plan_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_delete_backup_plan" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_delete_backup_plan" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.DeleteBackupPlanRequest.pb( + gkebackup.DeleteBackupPlanRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.DeleteBackupPlanRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.delete_backup_plan( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_delete_backup_plan_rest_bad_request( + transport: str = "rest", request_type=gkebackup.DeleteBackupPlanRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/backupPlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.delete_backup_plan(request) + + +def test_delete_backup_plan_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.delete_backup_plan(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/backupPlans/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_backup_plan_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_backup_plan( + gkebackup.DeleteBackupPlanRequest(), + name="name_value", + ) + + +def test_delete_backup_plan_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.CreateBackupRequest, + dict, + ], +) +def test_create_backup_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/backupPlans/sample3"} + request_init["backup"] = { + "name": "name_value", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "manual": True, + "labels": {}, + "delete_lock_days": 1675, + "delete_lock_expire_time": {}, + "retain_days": 1171, + "retain_expire_time": {}, + "encryption_key": {"gcp_kms_encryption_key": "gcp_kms_encryption_key_value"}, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [{"namespace": "namespace_value", "name": "name_value"}] + }, + "contains_volume_data": True, + "contains_secrets": True, + "cluster_metadata": { + "cluster": "cluster_value", + "k8s_version": "k8s_version_value", + "backup_crd_versions": {}, + "gke_version": "gke_version_value", + "anthos_version": "anthos_version_value", + }, + "state": 1, + "state_reason": "state_reason_value", + "complete_time": {}, + "resource_count": 1520, + "volume_count": 1312, + "size_bytes": 1089, + "etag": "etag_value", + "description": "description_value", + "pod_count": 971, + "config_backup_size_bytes": 2539, + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.create_backup(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_create_backup_rest_required_fields(request_type=gkebackup.CreateBackupRequest): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_backup._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["parent"] = "parent_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_backup._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("backup_id",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.create_backup(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_backup_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_backup._get_unset_required_fields({}) + assert set(unset_fields) == (set(("backupId",)) & set(("parent",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_backup_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_create_backup" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_create_backup" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.CreateBackupRequest.pb(gkebackup.CreateBackupRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.CreateBackupRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.create_backup( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_create_backup_rest_bad_request( + transport: str = "rest", request_type=gkebackup.CreateBackupRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/backupPlans/sample3"} + request_init["backup"] = { + "name": "name_value", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "manual": True, + "labels": {}, + "delete_lock_days": 1675, + "delete_lock_expire_time": {}, + "retain_days": 1171, + "retain_expire_time": {}, + "encryption_key": {"gcp_kms_encryption_key": "gcp_kms_encryption_key_value"}, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [{"namespace": "namespace_value", "name": "name_value"}] + }, + "contains_volume_data": True, + "contains_secrets": True, + "cluster_metadata": { + "cluster": "cluster_value", + "k8s_version": "k8s_version_value", + "backup_crd_versions": {}, + "gke_version": "gke_version_value", + "anthos_version": "anthos_version_value", + }, + "state": 1, + "state_reason": "state_reason_value", + "complete_time": {}, + "resource_count": 1520, + "volume_count": 1312, + "size_bytes": 1089, + "etag": "etag_value", + "description": "description_value", + "pod_count": 971, + "config_backup_size_bytes": 2539, + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.create_backup(request) + + +def test_create_backup_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "projects/sample1/locations/sample2/backupPlans/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + backup=gcg_backup.Backup(name="name_value"), + backup_id="backup_id_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.create_backup(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*/backupPlans/*}/backups" + % client.transport._host, + args[1], + ) + + +def test_create_backup_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_backup( + gkebackup.CreateBackupRequest(), + parent="parent_value", + backup=gcg_backup.Backup(name="name_value"), + backup_id="backup_id_value", + ) + + +def test_create_backup_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.ListBackupsRequest, + dict, + ], +) +def test_list_backups_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/backupPlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListBackupsResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListBackupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_backups(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListBackupsPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_backups_rest_required_fields(request_type=gkebackup.ListBackupsRequest): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_backups._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["parent"] = "parent_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_backups._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "order_by", + "page_size", + "page_token", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListBackupsResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = gkebackup.ListBackupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_backups(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_backups_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_backups._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_backups_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_list_backups" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_list_backups" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.ListBackupsRequest.pb(gkebackup.ListBackupsRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = gkebackup.ListBackupsResponse.to_json( + gkebackup.ListBackupsResponse() + ) + + request = gkebackup.ListBackupsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gkebackup.ListBackupsResponse() + + client.list_backups( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_backups_rest_bad_request( + transport: str = "rest", request_type=gkebackup.ListBackupsRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/backupPlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.list_backups(request) + + +def test_list_backups_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListBackupsResponse() + + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "projects/sample1/locations/sample2/backupPlans/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListBackupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_backups(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*/backupPlans/*}/backups" + % client.transport._host, + args[1], + ) + + +def test_list_backups_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_backups( + gkebackup.ListBackupsRequest(), + parent="parent_value", + ) + + +def test_list_backups_rest_pager(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + gkebackup.ListBackupsResponse( + backups=[ + backup.Backup(), + backup.Backup(), + backup.Backup(), + ], + next_page_token="abc", + ), + gkebackup.ListBackupsResponse( + backups=[], + next_page_token="def", + ), + gkebackup.ListBackupsResponse( + backups=[ + backup.Backup(), + ], + next_page_token="ghi", + ), + gkebackup.ListBackupsResponse( + backups=[ + backup.Backup(), + backup.Backup(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple(gkebackup.ListBackupsResponse.to_json(x) for x in response) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = { + "parent": "projects/sample1/locations/sample2/backupPlans/sample3" + } + + pager = client.list_backups(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, backup.Backup) for i in results) + + pages = list(client.list_backups(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.GetBackupRequest, + dict, + ], +) +def test_get_backup_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = backup.Backup( + name="name_value", + uid="uid_value", + manual=True, + delete_lock_days=1675, + retain_days=1171, + contains_volume_data=True, + contains_secrets=True, + state=backup.Backup.State.CREATING, + state_reason="state_reason_value", + resource_count=1520, + volume_count=1312, + size_bytes=1089, + etag="etag_value", + description="description_value", + pod_count=971, + config_backup_size_bytes=2539, + all_namespaces=True, + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = backup.Backup.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.get_backup(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, backup.Backup) + assert response.name == "name_value" + assert response.uid == "uid_value" + assert response.manual is True + assert response.delete_lock_days == 1675 + assert response.retain_days == 1171 + assert response.contains_volume_data is True + assert response.contains_secrets is True + assert response.state == backup.Backup.State.CREATING + assert response.state_reason == "state_reason_value" + assert response.resource_count == 1520 + assert response.volume_count == 1312 + assert response.size_bytes == 1089 + assert response.etag == "etag_value" + assert response.description == "description_value" + assert response.pod_count == 971 + assert response.config_backup_size_bytes == 2539 + + +def test_get_backup_rest_required_fields(request_type=gkebackup.GetBackupRequest): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_backup._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_backup._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = backup.Backup() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = backup.Backup.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.get_backup(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_backup_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_backup._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_backup_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_get_backup" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_get_backup" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.GetBackupRequest.pb(gkebackup.GetBackupRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = backup.Backup.to_json(backup.Backup()) + + request = gkebackup.GetBackupRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = backup.Backup() + + client.get_backup( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_get_backup_rest_bad_request( + transport: str = "rest", request_type=gkebackup.GetBackupRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.get_backup(request) + + +def test_get_backup_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = backup.Backup() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = backup.Backup.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.get_backup(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/backupPlans/*/backups/*}" + % client.transport._host, + args[1], + ) + + +def test_get_backup_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_backup( + gkebackup.GetBackupRequest(), + name="name_value", + ) + + +def test_get_backup_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.UpdateBackupRequest, + dict, + ], +) +def test_update_backup_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "backup": { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + } + request_init["backup"] = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "manual": True, + "labels": {}, + "delete_lock_days": 1675, + "delete_lock_expire_time": {}, + "retain_days": 1171, + "retain_expire_time": {}, + "encryption_key": {"gcp_kms_encryption_key": "gcp_kms_encryption_key_value"}, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [{"namespace": "namespace_value", "name": "name_value"}] + }, + "contains_volume_data": True, + "contains_secrets": True, + "cluster_metadata": { + "cluster": "cluster_value", + "k8s_version": "k8s_version_value", + "backup_crd_versions": {}, + "gke_version": "gke_version_value", + "anthos_version": "anthos_version_value", + }, + "state": 1, + "state_reason": "state_reason_value", + "complete_time": {}, + "resource_count": 1520, + "volume_count": 1312, + "size_bytes": 1089, + "etag": "etag_value", + "description": "description_value", + "pod_count": 971, + "config_backup_size_bytes": 2539, + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.update_backup(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_update_backup_rest_required_fields(request_type=gkebackup.UpdateBackupRequest): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_backup._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_backup._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("update_mask",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "patch", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.update_backup(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_update_backup_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.update_backup._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("backup",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_backup_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_update_backup" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_update_backup" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.UpdateBackupRequest.pb(gkebackup.UpdateBackupRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.UpdateBackupRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.update_backup( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_update_backup_rest_bad_request( + transport: str = "rest", request_type=gkebackup.UpdateBackupRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "backup": { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + } + request_init["backup"] = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "manual": True, + "labels": {}, + "delete_lock_days": 1675, + "delete_lock_expire_time": {}, + "retain_days": 1171, + "retain_expire_time": {}, + "encryption_key": {"gcp_kms_encryption_key": "gcp_kms_encryption_key_value"}, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [{"namespace": "namespace_value", "name": "name_value"}] + }, + "contains_volume_data": True, + "contains_secrets": True, + "cluster_metadata": { + "cluster": "cluster_value", + "k8s_version": "k8s_version_value", + "backup_crd_versions": {}, + "gke_version": "gke_version_value", + "anthos_version": "anthos_version_value", + }, + "state": 1, + "state_reason": "state_reason_value", + "complete_time": {}, + "resource_count": 1520, + "volume_count": 1312, + "size_bytes": 1089, + "etag": "etag_value", + "description": "description_value", + "pod_count": 971, + "config_backup_size_bytes": 2539, + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.update_backup(request) + + +def test_update_backup_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "backup": { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + } + + # get truthy value for each flattened field + mock_args = dict( + backup=gcg_backup.Backup(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.update_backup(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{backup.name=projects/*/locations/*/backupPlans/*/backups/*}" + % client.transport._host, + args[1], + ) + + +def test_update_backup_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_backup( + gkebackup.UpdateBackupRequest(), + backup=gcg_backup.Backup(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_update_backup_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.DeleteBackupRequest, + dict, + ], +) +def test_delete_backup_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.delete_backup(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_delete_backup_rest_required_fields(request_type=gkebackup.DeleteBackupRequest): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_backup._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_backup._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "etag", + "force", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "delete", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.delete_backup(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_backup_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_backup._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "etag", + "force", + ) + ) + & set(("name",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_backup_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_delete_backup" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_delete_backup" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.DeleteBackupRequest.pb(gkebackup.DeleteBackupRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.DeleteBackupRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.delete_backup( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_delete_backup_rest_bad_request( + transport: str = "rest", request_type=gkebackup.DeleteBackupRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.delete_backup(request) + + +def test_delete_backup_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.delete_backup(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/backupPlans/*/backups/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_backup_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_backup( + gkebackup.DeleteBackupRequest(), + name="name_value", + ) + + +def test_delete_backup_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.ListVolumeBackupsRequest, + dict, + ], +) +def test_list_volume_backups_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "parent": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListVolumeBackupsResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListVolumeBackupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_volume_backups(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListVolumeBackupsPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_volume_backups_rest_required_fields( + request_type=gkebackup.ListVolumeBackupsRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_volume_backups._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["parent"] = "parent_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_volume_backups._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "order_by", + "page_size", + "page_token", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListVolumeBackupsResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = gkebackup.ListVolumeBackupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_volume_backups(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_volume_backups_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_volume_backups._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_volume_backups_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_list_volume_backups" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_list_volume_backups" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.ListVolumeBackupsRequest.pb( + gkebackup.ListVolumeBackupsRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = gkebackup.ListVolumeBackupsResponse.to_json( + gkebackup.ListVolumeBackupsResponse() + ) + + request = gkebackup.ListVolumeBackupsRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gkebackup.ListVolumeBackupsResponse() + + client.list_volume_backups( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_volume_backups_rest_bad_request( + transport: str = "rest", request_type=gkebackup.ListVolumeBackupsRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "parent": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.list_volume_backups(request) + + +def test_list_volume_backups_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListVolumeBackupsResponse() + + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListVolumeBackupsResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_volume_backups(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*/backupPlans/*/backups/*}/volumeBackups" + % client.transport._host, + args[1], + ) + + +def test_list_volume_backups_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_volume_backups( + gkebackup.ListVolumeBackupsRequest(), + parent="parent_value", + ) + + +def test_list_volume_backups_rest_pager(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + gkebackup.ListVolumeBackupsResponse( + volume_backups=[ + volume.VolumeBackup(), + volume.VolumeBackup(), + volume.VolumeBackup(), + ], + next_page_token="abc", + ), + gkebackup.ListVolumeBackupsResponse( + volume_backups=[], + next_page_token="def", + ), + gkebackup.ListVolumeBackupsResponse( + volume_backups=[ + volume.VolumeBackup(), + ], + next_page_token="ghi", + ), + gkebackup.ListVolumeBackupsResponse( + volume_backups=[ + volume.VolumeBackup(), + volume.VolumeBackup(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + gkebackup.ListVolumeBackupsResponse.to_json(x) for x in response + ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = { + "parent": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4" + } + + pager = client.list_volume_backups(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, volume.VolumeBackup) for i in results) + + pages = list(client.list_volume_backups(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.GetVolumeBackupRequest, + dict, + ], +) +def test_get_volume_backup_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4/volumeBackups/sample5" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = volume.VolumeBackup( + name="name_value", + uid="uid_value", + volume_backup_handle="volume_backup_handle_value", + format_=volume.VolumeBackup.VolumeBackupFormat.GCE_PERSISTENT_DISK, + storage_bytes=1403, + disk_size_bytes=1611, + state=volume.VolumeBackup.State.CREATING, + state_message="state_message_value", + etag="etag_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = volume.VolumeBackup.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.get_volume_backup(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, volume.VolumeBackup) + assert response.name == "name_value" + assert response.uid == "uid_value" + assert response.volume_backup_handle == "volume_backup_handle_value" + assert ( + response.format_ == volume.VolumeBackup.VolumeBackupFormat.GCE_PERSISTENT_DISK + ) + assert response.storage_bytes == 1403 + assert response.disk_size_bytes == 1611 + assert response.state == volume.VolumeBackup.State.CREATING + assert response.state_message == "state_message_value" + assert response.etag == "etag_value" + + +def test_get_volume_backup_rest_required_fields( + request_type=gkebackup.GetVolumeBackupRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_volume_backup._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_volume_backup._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = volume.VolumeBackup() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = volume.VolumeBackup.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.get_volume_backup(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_volume_backup_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_volume_backup._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_volume_backup_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_get_volume_backup" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_get_volume_backup" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.GetVolumeBackupRequest.pb( + gkebackup.GetVolumeBackupRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = volume.VolumeBackup.to_json(volume.VolumeBackup()) + + request = gkebackup.GetVolumeBackupRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = volume.VolumeBackup() + + client.get_volume_backup( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_get_volume_backup_rest_bad_request( + transport: str = "rest", request_type=gkebackup.GetVolumeBackupRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4/volumeBackups/sample5" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.get_volume_backup(request) + + +def test_get_volume_backup_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = volume.VolumeBackup() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/backupPlans/sample3/backups/sample4/volumeBackups/sample5" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = volume.VolumeBackup.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.get_volume_backup(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/backupPlans/*/backups/*/volumeBackups/*}" + % client.transport._host, + args[1], + ) + + +def test_get_volume_backup_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_volume_backup( + gkebackup.GetVolumeBackupRequest(), + name="name_value", + ) + + +def test_get_volume_backup_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.CreateRestorePlanRequest, + dict, + ], +) +def test_create_restore_plan_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request_init["restore_plan"] = { + "name": "name_value", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "backup_plan": "backup_plan_value", + "cluster": "cluster_value", + "restore_config": { + "volume_data_restore_policy": 1, + "cluster_resource_conflict_policy": 1, + "namespaced_resource_restore_mode": 1, + "cluster_resource_restore_scope": { + "selected_group_kinds": [ + { + "resource_group": "resource_group_value", + "resource_kind": "resource_kind_value", + } + ] + }, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "substitution_rules": [ + { + "target_namespaces": [ + "target_namespaces_value1", + "target_namespaces_value2", + ], + "target_group_kinds": {}, + "target_json_path": "target_json_path_value", + "original_value_pattern": "original_value_pattern_value", + "new_value": "new_value_value", + } + ], + }, + "labels": {}, + "etag": "etag_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.create_restore_plan(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_create_restore_plan_rest_required_fields( + request_type=gkebackup.CreateRestorePlanRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request_init["restore_plan_id"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + assert "restorePlanId" not in jsonified_request + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_restore_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + assert "restorePlanId" in jsonified_request + assert jsonified_request["restorePlanId"] == request_init["restore_plan_id"] + + jsonified_request["parent"] = "parent_value" + jsonified_request["restorePlanId"] = "restore_plan_id_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_restore_plan._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("restore_plan_id",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + assert "restorePlanId" in jsonified_request + assert jsonified_request["restorePlanId"] == "restore_plan_id_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.create_restore_plan(request) + + expected_params = [ + ( + "restorePlanId", + "", + ), + ] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_restore_plan_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_restore_plan._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("restorePlanId",)) + & set( + ( + "parent", + "restorePlan", + "restorePlanId", + ) + ) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_restore_plan_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_create_restore_plan" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_create_restore_plan" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.CreateRestorePlanRequest.pb( + gkebackup.CreateRestorePlanRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.CreateRestorePlanRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.create_restore_plan( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_create_restore_plan_rest_bad_request( + transport: str = "rest", request_type=gkebackup.CreateRestorePlanRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request_init["restore_plan"] = { + "name": "name_value", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "backup_plan": "backup_plan_value", + "cluster": "cluster_value", + "restore_config": { + "volume_data_restore_policy": 1, + "cluster_resource_conflict_policy": 1, + "namespaced_resource_restore_mode": 1, + "cluster_resource_restore_scope": { + "selected_group_kinds": [ + { + "resource_group": "resource_group_value", + "resource_kind": "resource_kind_value", + } + ] + }, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "substitution_rules": [ + { + "target_namespaces": [ + "target_namespaces_value1", + "target_namespaces_value2", + ], + "target_group_kinds": {}, + "target_json_path": "target_json_path_value", + "original_value_pattern": "original_value_pattern_value", + "new_value": "new_value_value", + } + ], + }, + "labels": {}, + "etag": "etag_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.create_restore_plan(request) + + +def test_create_restore_plan_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + restore_plan=gcg_restore_plan.RestorePlan(name="name_value"), + restore_plan_id="restore_plan_id_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.create_restore_plan(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*}/restorePlans" + % client.transport._host, + args[1], + ) + + +def test_create_restore_plan_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_restore_plan( + gkebackup.CreateRestorePlanRequest(), + parent="parent_value", + restore_plan=gcg_restore_plan.RestorePlan(name="name_value"), + restore_plan_id="restore_plan_id_value", + ) + + +def test_create_restore_plan_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.ListRestorePlansRequest, + dict, + ], +) +def test_list_restore_plans_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListRestorePlansResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListRestorePlansResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_restore_plans(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListRestorePlansPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] + + +def test_list_restore_plans_rest_required_fields( + request_type=gkebackup.ListRestorePlansRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_restore_plans._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["parent"] = "parent_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_restore_plans._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "order_by", + "page_size", + "page_token", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListRestorePlansResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = gkebackup.ListRestorePlansResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_restore_plans(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_restore_plans_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_restore_plans._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_restore_plans_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_list_restore_plans" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_list_restore_plans" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.ListRestorePlansRequest.pb( + gkebackup.ListRestorePlansRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = gkebackup.ListRestorePlansResponse.to_json( + gkebackup.ListRestorePlansResponse() + ) + + request = gkebackup.ListRestorePlansRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gkebackup.ListRestorePlansResponse() + + client.list_restore_plans( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_restore_plans_rest_bad_request( + transport: str = "rest", request_type=gkebackup.ListRestorePlansRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.list_restore_plans(request) + + +def test_list_restore_plans_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListRestorePlansResponse() + + # get arguments that satisfy an http rule for this method + sample_request = {"parent": "projects/sample1/locations/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListRestorePlansResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_restore_plans(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*}/restorePlans" + % client.transport._host, + args[1], + ) + + +def test_list_restore_plans_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_restore_plans( + gkebackup.ListRestorePlansRequest(), + parent="parent_value", + ) + + +def test_list_restore_plans_rest_pager(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + gkebackup.ListRestorePlansResponse( + restore_plans=[ + restore_plan.RestorePlan(), + restore_plan.RestorePlan(), + restore_plan.RestorePlan(), + ], + next_page_token="abc", + ), + gkebackup.ListRestorePlansResponse( + restore_plans=[], + next_page_token="def", + ), + gkebackup.ListRestorePlansResponse( + restore_plans=[ + restore_plan.RestorePlan(), + ], + next_page_token="ghi", + ), + gkebackup.ListRestorePlansResponse( + restore_plans=[ + restore_plan.RestorePlan(), + restore_plan.RestorePlan(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + gkebackup.ListRestorePlansResponse.to_json(x) for x in response + ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = {"parent": "projects/sample1/locations/sample2"} + + pager = client.list_restore_plans(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, restore_plan.RestorePlan) for i in results) + + pages = list(client.list_restore_plans(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.GetRestorePlanRequest, + dict, + ], +) +def test_get_restore_plan_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/restorePlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = restore_plan.RestorePlan( + name="name_value", + uid="uid_value", + description="description_value", + backup_plan="backup_plan_value", + cluster="cluster_value", + etag="etag_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = restore_plan.RestorePlan.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.get_restore_plan(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, restore_plan.RestorePlan) + assert response.name == "name_value" + assert response.uid == "uid_value" + assert response.description == "description_value" + assert response.backup_plan == "backup_plan_value" + assert response.cluster == "cluster_value" + assert response.etag == "etag_value" + + +def test_get_restore_plan_rest_required_fields( + request_type=gkebackup.GetRestorePlanRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_restore_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_restore_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = restore_plan.RestorePlan() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = restore_plan.RestorePlan.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.get_restore_plan(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_restore_plan_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_restore_plan._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_restore_plan_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_get_restore_plan" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_get_restore_plan" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.GetRestorePlanRequest.pb( + gkebackup.GetRestorePlanRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = restore_plan.RestorePlan.to_json( + restore_plan.RestorePlan() + ) + + request = gkebackup.GetRestorePlanRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = restore_plan.RestorePlan() + + client.get_restore_plan( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_get_restore_plan_rest_bad_request( + transport: str = "rest", request_type=gkebackup.GetRestorePlanRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/restorePlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.get_restore_plan(request) + + +def test_get_restore_plan_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = restore_plan.RestorePlan() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = restore_plan.RestorePlan.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.get_restore_plan(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/restorePlans/*}" + % client.transport._host, + args[1], + ) + + +def test_get_restore_plan_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_restore_plan( + gkebackup.GetRestorePlanRequest(), + name="name_value", + ) + + +def test_get_restore_plan_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.UpdateRestorePlanRequest, + dict, + ], +) +def test_update_restore_plan_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "restore_plan": { + "name": "projects/sample1/locations/sample2/restorePlans/sample3" + } + } + request_init["restore_plan"] = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "backup_plan": "backup_plan_value", + "cluster": "cluster_value", + "restore_config": { + "volume_data_restore_policy": 1, + "cluster_resource_conflict_policy": 1, + "namespaced_resource_restore_mode": 1, + "cluster_resource_restore_scope": { + "selected_group_kinds": [ + { + "resource_group": "resource_group_value", + "resource_kind": "resource_kind_value", + } + ] + }, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "substitution_rules": [ + { + "target_namespaces": [ + "target_namespaces_value1", + "target_namespaces_value2", + ], + "target_group_kinds": {}, + "target_json_path": "target_json_path_value", + "original_value_pattern": "original_value_pattern_value", + "new_value": "new_value_value", + } + ], + }, + "labels": {}, + "etag": "etag_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.update_restore_plan(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_update_restore_plan_rest_required_fields( + request_type=gkebackup.UpdateRestorePlanRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_restore_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_restore_plan._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("update_mask",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "patch", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.update_restore_plan(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_update_restore_plan_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.update_restore_plan._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("restorePlan",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_restore_plan_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_update_restore_plan" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_update_restore_plan" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.UpdateRestorePlanRequest.pb( + gkebackup.UpdateRestorePlanRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.UpdateRestorePlanRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.update_restore_plan( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_update_restore_plan_rest_bad_request( + transport: str = "rest", request_type=gkebackup.UpdateRestorePlanRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "restore_plan": { + "name": "projects/sample1/locations/sample2/restorePlans/sample3" + } + } + request_init["restore_plan"] = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "backup_plan": "backup_plan_value", + "cluster": "cluster_value", + "restore_config": { + "volume_data_restore_policy": 1, + "cluster_resource_conflict_policy": 1, + "namespaced_resource_restore_mode": 1, + "cluster_resource_restore_scope": { + "selected_group_kinds": [ + { + "resource_group": "resource_group_value", + "resource_kind": "resource_kind_value", + } + ] + }, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "substitution_rules": [ + { + "target_namespaces": [ + "target_namespaces_value1", + "target_namespaces_value2", + ], + "target_group_kinds": {}, + "target_json_path": "target_json_path_value", + "original_value_pattern": "original_value_pattern_value", + "new_value": "new_value_value", + } + ], + }, + "labels": {}, + "etag": "etag_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.update_restore_plan(request) + + +def test_update_restore_plan_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "restore_plan": { + "name": "projects/sample1/locations/sample2/restorePlans/sample3" + } + } + + # get truthy value for each flattened field + mock_args = dict( + restore_plan=gcg_restore_plan.RestorePlan(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.update_restore_plan(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{restore_plan.name=projects/*/locations/*/restorePlans/*}" + % client.transport._host, + args[1], + ) + + +def test_update_restore_plan_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_restore_plan( + gkebackup.UpdateRestorePlanRequest(), + restore_plan=gcg_restore_plan.RestorePlan(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_update_restore_plan_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.DeleteRestorePlanRequest, + dict, + ], +) +def test_delete_restore_plan_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/restorePlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.delete_restore_plan(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_delete_restore_plan_rest_required_fields( + request_type=gkebackup.DeleteRestorePlanRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_restore_plan._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_restore_plan._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "etag", + "force", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "delete", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.delete_restore_plan(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_restore_plan_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_restore_plan._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "etag", + "force", + ) + ) + & set(("name",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_restore_plan_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_delete_restore_plan" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_delete_restore_plan" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.DeleteRestorePlanRequest.pb( + gkebackup.DeleteRestorePlanRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.DeleteRestorePlanRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.delete_restore_plan( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_delete_restore_plan_rest_bad_request( + transport: str = "rest", request_type=gkebackup.DeleteRestorePlanRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"name": "projects/sample1/locations/sample2/restorePlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.delete_restore_plan(request) + + +def test_delete_restore_plan_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.delete_restore_plan(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/restorePlans/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_restore_plan_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_restore_plan( + gkebackup.DeleteRestorePlanRequest(), + name="name_value", + ) + + +def test_delete_restore_plan_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.CreateRestoreRequest, + dict, + ], +) +def test_create_restore_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/restorePlans/sample3"} + request_init["restore"] = { + "name": "name_value", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "backup": "backup_value", + "cluster": "cluster_value", + "restore_config": { + "volume_data_restore_policy": 1, + "cluster_resource_conflict_policy": 1, + "namespaced_resource_restore_mode": 1, + "cluster_resource_restore_scope": { + "selected_group_kinds": [ + { + "resource_group": "resource_group_value", + "resource_kind": "resource_kind_value", + } + ] + }, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "substitution_rules": [ + { + "target_namespaces": [ + "target_namespaces_value1", + "target_namespaces_value2", + ], + "target_group_kinds": {}, + "target_json_path": "target_json_path_value", + "original_value_pattern": "original_value_pattern_value", + "new_value": "new_value_value", + } + ], + }, + "labels": {}, + "state": 1, + "state_reason": "state_reason_value", + "complete_time": {}, + "resources_restored_count": 2602, + "resources_excluded_count": 2576, + "resources_failed_count": 2343, + "volumes_restored_count": 2394, + "etag": "etag_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.create_restore(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_create_restore_rest_required_fields( + request_type=gkebackup.CreateRestoreRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request_init["restore_id"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + assert "restoreId" not in jsonified_request + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_restore._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + assert "restoreId" in jsonified_request + assert jsonified_request["restoreId"] == request_init["restore_id"] + + jsonified_request["parent"] = "parent_value" + jsonified_request["restoreId"] = "restore_id_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).create_restore._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("restore_id",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + assert "restoreId" in jsonified_request + assert jsonified_request["restoreId"] == "restore_id_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "post", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.create_restore(request) + + expected_params = [ + ( + "restoreId", + "", + ), + ] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_create_restore_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.create_restore._get_unset_required_fields({}) + assert set(unset_fields) == ( + set(("restoreId",)) + & set( + ( + "parent", + "restore", + "restoreId", + ) + ) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_restore_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_create_restore" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_create_restore" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.CreateRestoreRequest.pb(gkebackup.CreateRestoreRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.CreateRestoreRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.create_restore( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_create_restore_rest_bad_request( + transport: str = "rest", request_type=gkebackup.CreateRestoreRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/restorePlans/sample3"} + request_init["restore"] = { + "name": "name_value", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "backup": "backup_value", + "cluster": "cluster_value", + "restore_config": { + "volume_data_restore_policy": 1, + "cluster_resource_conflict_policy": 1, + "namespaced_resource_restore_mode": 1, + "cluster_resource_restore_scope": { + "selected_group_kinds": [ + { + "resource_group": "resource_group_value", + "resource_kind": "resource_kind_value", + } + ] + }, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "substitution_rules": [ + { + "target_namespaces": [ + "target_namespaces_value1", + "target_namespaces_value2", + ], + "target_group_kinds": {}, + "target_json_path": "target_json_path_value", + "original_value_pattern": "original_value_pattern_value", + "new_value": "new_value_value", + } + ], + }, + "labels": {}, + "state": 1, + "state_reason": "state_reason_value", + "complete_time": {}, + "resources_restored_count": 2602, + "resources_excluded_count": 2576, + "resources_failed_count": 2343, + "volumes_restored_count": 2394, + "etag": "etag_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.create_restore(request) + + +def test_create_restore_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "projects/sample1/locations/sample2/restorePlans/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + restore=gcg_restore.Restore(name="name_value"), + restore_id="restore_id_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.create_restore(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*/restorePlans/*}/restores" + % client.transport._host, + args[1], + ) + + +def test_create_restore_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.create_restore( + gkebackup.CreateRestoreRequest(), + parent="parent_value", + restore=gcg_restore.Restore(name="name_value"), + restore_id="restore_id_value", + ) + + +def test_create_restore_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.ListRestoresRequest, + dict, + ], +) +def test_list_restores_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/restorePlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListRestoresResponse( + next_page_token="next_page_token_value", + unreachable=["unreachable_value"], + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListRestoresResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_restores(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListRestoresPager) + assert response.next_page_token == "next_page_token_value" + assert response.unreachable == ["unreachable_value"] + + +def test_list_restores_rest_required_fields(request_type=gkebackup.ListRestoresRequest): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_restores._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["parent"] = "parent_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_restores._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "order_by", + "page_size", + "page_token", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListRestoresResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = gkebackup.ListRestoresResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_restores(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_restores_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_restores._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_restores_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_list_restores" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_list_restores" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.ListRestoresRequest.pb(gkebackup.ListRestoresRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = gkebackup.ListRestoresResponse.to_json( + gkebackup.ListRestoresResponse() + ) + + request = gkebackup.ListRestoresRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gkebackup.ListRestoresResponse() + + client.list_restores( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_restores_rest_bad_request( + transport: str = "rest", request_type=gkebackup.ListRestoresRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = {"parent": "projects/sample1/locations/sample2/restorePlans/sample3"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.list_restores(request) + + +def test_list_restores_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListRestoresResponse() + + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "projects/sample1/locations/sample2/restorePlans/sample3" + } + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListRestoresResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_restores(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*/restorePlans/*}/restores" + % client.transport._host, + args[1], + ) + + +def test_list_restores_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_restores( + gkebackup.ListRestoresRequest(), + parent="parent_value", + ) + + +def test_list_restores_rest_pager(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + gkebackup.ListRestoresResponse( + restores=[ + restore.Restore(), + restore.Restore(), + restore.Restore(), + ], + next_page_token="abc", + ), + gkebackup.ListRestoresResponse( + restores=[], + next_page_token="def", + ), + gkebackup.ListRestoresResponse( + restores=[ + restore.Restore(), + ], + next_page_token="ghi", + ), + gkebackup.ListRestoresResponse( + restores=[ + restore.Restore(), + restore.Restore(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple(gkebackup.ListRestoresResponse.to_json(x) for x in response) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = { + "parent": "projects/sample1/locations/sample2/restorePlans/sample3" + } + + pager = client.list_restores(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, restore.Restore) for i in results) + + pages = list(client.list_restores(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.GetRestoreRequest, + dict, + ], +) +def test_get_restore_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = restore.Restore( + name="name_value", + uid="uid_value", + description="description_value", + backup="backup_value", + cluster="cluster_value", + state=restore.Restore.State.CREATING, + state_reason="state_reason_value", + resources_restored_count=2602, + resources_excluded_count=2576, + resources_failed_count=2343, + volumes_restored_count=2394, + etag="etag_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = restore.Restore.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.get_restore(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, restore.Restore) + assert response.name == "name_value" + assert response.uid == "uid_value" + assert response.description == "description_value" + assert response.backup == "backup_value" + assert response.cluster == "cluster_value" + assert response.state == restore.Restore.State.CREATING + assert response.state_reason == "state_reason_value" + assert response.resources_restored_count == 2602 + assert response.resources_excluded_count == 2576 + assert response.resources_failed_count == 2343 + assert response.volumes_restored_count == 2394 + assert response.etag == "etag_value" + + +def test_get_restore_rest_required_fields(request_type=gkebackup.GetRestoreRequest): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_restore._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_restore._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = restore.Restore() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = restore.Restore.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.get_restore(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_restore_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_restore._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_restore_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_get_restore" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_get_restore" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.GetRestoreRequest.pb(gkebackup.GetRestoreRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = restore.Restore.to_json(restore.Restore()) + + request = gkebackup.GetRestoreRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = restore.Restore() + + client.get_restore( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_get_restore_rest_bad_request( + transport: str = "rest", request_type=gkebackup.GetRestoreRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.get_restore(request) + + +def test_get_restore_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = restore.Restore() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = restore.Restore.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.get_restore(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/restorePlans/*/restores/*}" + % client.transport._host, + args[1], + ) + + +def test_get_restore_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_restore( + gkebackup.GetRestoreRequest(), + name="name_value", + ) + + +def test_get_restore_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.UpdateRestoreRequest, + dict, + ], +) +def test_update_restore_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "restore": { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + } + request_init["restore"] = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "backup": "backup_value", + "cluster": "cluster_value", + "restore_config": { + "volume_data_restore_policy": 1, + "cluster_resource_conflict_policy": 1, + "namespaced_resource_restore_mode": 1, + "cluster_resource_restore_scope": { + "selected_group_kinds": [ + { + "resource_group": "resource_group_value", + "resource_kind": "resource_kind_value", + } + ] + }, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "substitution_rules": [ + { + "target_namespaces": [ + "target_namespaces_value1", + "target_namespaces_value2", + ], + "target_group_kinds": {}, + "target_json_path": "target_json_path_value", + "original_value_pattern": "original_value_pattern_value", + "new_value": "new_value_value", + } + ], + }, + "labels": {}, + "state": 1, + "state_reason": "state_reason_value", + "complete_time": {}, + "resources_restored_count": 2602, + "resources_excluded_count": 2576, + "resources_failed_count": 2343, + "volumes_restored_count": 2394, + "etag": "etag_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.update_restore(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_update_restore_rest_required_fields( + request_type=gkebackup.UpdateRestoreRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_restore._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_restore._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("update_mask",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "patch", + "query_params": pb_request, + } + transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.update_restore(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_update_restore_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.update_restore._get_unset_required_fields({}) + assert set(unset_fields) == (set(("updateMask",)) & set(("restore",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_update_restore_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_update_restore" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_update_restore" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.UpdateRestoreRequest.pb(gkebackup.UpdateRestoreRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.UpdateRestoreRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.update_restore( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_update_restore_rest_bad_request( + transport: str = "rest", request_type=gkebackup.UpdateRestoreRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "restore": { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + } + request_init["restore"] = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4", + "uid": "uid_value", + "create_time": {"seconds": 751, "nanos": 543}, + "update_time": {}, + "description": "description_value", + "backup": "backup_value", + "cluster": "cluster_value", + "restore_config": { + "volume_data_restore_policy": 1, + "cluster_resource_conflict_policy": 1, + "namespaced_resource_restore_mode": 1, + "cluster_resource_restore_scope": { + "selected_group_kinds": [ + { + "resource_group": "resource_group_value", + "resource_kind": "resource_kind_value", + } + ] + }, + "all_namespaces": True, + "selected_namespaces": { + "namespaces": ["namespaces_value1", "namespaces_value2"] + }, + "selected_applications": { + "namespaced_names": [ + {"namespace": "namespace_value", "name": "name_value"} + ] + }, + "substitution_rules": [ + { + "target_namespaces": [ + "target_namespaces_value1", + "target_namespaces_value2", + ], + "target_group_kinds": {}, + "target_json_path": "target_json_path_value", + "original_value_pattern": "original_value_pattern_value", + "new_value": "new_value_value", + } + ], + }, + "labels": {}, + "state": 1, + "state_reason": "state_reason_value", + "complete_time": {}, + "resources_restored_count": 2602, + "resources_excluded_count": 2576, + "resources_failed_count": 2343, + "volumes_restored_count": 2394, + "etag": "etag_value", + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.update_restore(request) + + +def test_update_restore_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "restore": { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + } + + # get truthy value for each flattened field + mock_args = dict( + restore=gcg_restore.Restore(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.update_restore(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{restore.name=projects/*/locations/*/restorePlans/*/restores/*}" + % client.transport._host, + args[1], + ) + + +def test_update_restore_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.update_restore( + gkebackup.UpdateRestoreRequest(), + restore=gcg_restore.Restore(name="name_value"), + update_mask=field_mask_pb2.FieldMask(paths=["paths_value"]), + ) + + +def test_update_restore_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.DeleteRestoreRequest, + dict, + ], +) +def test_delete_restore_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.delete_restore(request) + + # Establish that the response is the type that we expect. + assert response.operation.name == "operations/spam" + + +def test_delete_restore_rest_required_fields( + request_type=gkebackup.DeleteRestoreRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_restore._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_restore._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "etag", + "force", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "delete", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.delete_restore(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_restore_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_restore._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "etag", + "force", + ) + ) + & set(("name",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_restore_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + operation.Operation, "_set_result_from_operation" + ), mock.patch.object( + transports.BackupForGKERestInterceptor, "post_delete_restore" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_delete_restore" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.DeleteRestoreRequest.pb(gkebackup.DeleteRestoreRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = json_format.MessageToJson( + operations_pb2.Operation() + ) + + request = gkebackup.DeleteRestoreRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = operations_pb2.Operation() + + client.delete_restore( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_delete_restore_rest_bad_request( + transport: str = "rest", request_type=gkebackup.DeleteRestoreRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.delete_restore(request) + + +def test_delete_restore_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = operations_pb2.Operation(name="operations/spam") + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_return_value = json_format.MessageToJson(return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.delete_restore(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/restorePlans/*/restores/*}" + % client.transport._host, + args[1], + ) + + +def test_delete_restore_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_restore( + gkebackup.DeleteRestoreRequest(), + name="name_value", + ) + + +def test_delete_restore_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.ListVolumeRestoresRequest, + dict, + ], +) +def test_list_volume_restores_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "parent": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListVolumeRestoresResponse( + next_page_token="next_page_token_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListVolumeRestoresResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.list_volume_restores(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, pagers.ListVolumeRestoresPager) + assert response.next_page_token == "next_page_token_value" + + +def test_list_volume_restores_rest_required_fields( + request_type=gkebackup.ListVolumeRestoresRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["parent"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_volume_restores._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["parent"] = "parent_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).list_volume_restores._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "filter", + "order_by", + "page_size", + "page_token", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "parent" in jsonified_request + assert jsonified_request["parent"] == "parent_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListVolumeRestoresResponse() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = gkebackup.ListVolumeRestoresResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.list_volume_restores(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_list_volume_restores_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.list_volume_restores._get_unset_required_fields({}) + assert set(unset_fields) == ( + set( + ( + "filter", + "orderBy", + "pageSize", + "pageToken", + ) + ) + & set(("parent",)) + ) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_list_volume_restores_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_list_volume_restores" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_list_volume_restores" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.ListVolumeRestoresRequest.pb( + gkebackup.ListVolumeRestoresRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = gkebackup.ListVolumeRestoresResponse.to_json( + gkebackup.ListVolumeRestoresResponse() + ) + + request = gkebackup.ListVolumeRestoresRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = gkebackup.ListVolumeRestoresResponse() + + client.list_volume_restores( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_list_volume_restores_rest_bad_request( + transport: str = "rest", request_type=gkebackup.ListVolumeRestoresRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "parent": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.list_volume_restores(request) + + +def test_list_volume_restores_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = gkebackup.ListVolumeRestoresResponse() + + # get arguments that satisfy an http rule for this method + sample_request = { + "parent": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + + # get truthy value for each flattened field + mock_args = dict( + parent="parent_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = gkebackup.ListVolumeRestoresResponse.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.list_volume_restores(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{parent=projects/*/locations/*/restorePlans/*/restores/*}/volumeRestores" + % client.transport._host, + args[1], + ) + + +def test_list_volume_restores_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.list_volume_restores( + gkebackup.ListVolumeRestoresRequest(), + parent="parent_value", + ) + + +def test_list_volume_restores_rest_pager(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # TODO(kbandes): remove this mock unless there's a good reason for it. + # with mock.patch.object(path_template, 'transcode') as transcode: + # Set the response as a series of pages + response = ( + gkebackup.ListVolumeRestoresResponse( + volume_restores=[ + volume.VolumeRestore(), + volume.VolumeRestore(), + volume.VolumeRestore(), + ], + next_page_token="abc", + ), + gkebackup.ListVolumeRestoresResponse( + volume_restores=[], + next_page_token="def", + ), + gkebackup.ListVolumeRestoresResponse( + volume_restores=[ + volume.VolumeRestore(), + ], + next_page_token="ghi", + ), + gkebackup.ListVolumeRestoresResponse( + volume_restores=[ + volume.VolumeRestore(), + volume.VolumeRestore(), + ], + ), + ) + # Two responses for two calls + response = response + response + + # Wrap the values into proper Response objs + response = tuple( + gkebackup.ListVolumeRestoresResponse.to_json(x) for x in response + ) + return_values = tuple(Response() for i in response) + for return_val, response_val in zip(return_values, response): + return_val._content = response_val.encode("UTF-8") + return_val.status_code = 200 + req.side_effect = return_values + + sample_request = { + "parent": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4" + } + + pager = client.list_volume_restores(request=sample_request) + + results = list(pager) + assert len(results) == 6 + assert all(isinstance(i, volume.VolumeRestore) for i in results) + + pages = list(client.list_volume_restores(request=sample_request).pages) + for page_, token in zip(pages, ["abc", "def", "ghi", ""]): + assert page_.raw_page.next_page_token == token + + +@pytest.mark.parametrize( + "request_type", + [ + gkebackup.GetVolumeRestoreRequest, + dict, + ], +) +def test_get_volume_restore_rest(request_type): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4/volumeRestores/sample5" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = volume.VolumeRestore( + name="name_value", + uid="uid_value", + volume_backup="volume_backup_value", + volume_handle="volume_handle_value", + volume_type=volume.VolumeRestore.VolumeType.GCE_PERSISTENT_DISK, + state=volume.VolumeRestore.State.CREATING, + state_message="state_message_value", + etag="etag_value", + ) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = volume.VolumeRestore.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + response = client.get_volume_restore(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, volume.VolumeRestore) + assert response.name == "name_value" + assert response.uid == "uid_value" + assert response.volume_backup == "volume_backup_value" + assert response.volume_handle == "volume_handle_value" + assert response.volume_type == volume.VolumeRestore.VolumeType.GCE_PERSISTENT_DISK + assert response.state == volume.VolumeRestore.State.CREATING + assert response.state_message == "state_message_value" + assert response.etag == "etag_value" + + +def test_get_volume_restore_rest_required_fields( + request_type=gkebackup.GetVolumeRestoreRequest, +): + transport_class = transports.BackupForGKERestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson( + pb_request, + including_default_value_fields=False, + use_integers_for_enums=False, + ) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_volume_restore._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).get_volume_restore._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = volume.VolumeRestore() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "get", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + + pb_return_value = volume.VolumeRestore.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + response = client.get_volume_restore(request) + + expected_params = [] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_get_volume_restore_rest_unset_required_fields(): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.get_volume_restore._get_unset_required_fields({}) + assert set(unset_fields) == (set(()) & set(("name",))) + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_get_volume_restore_rest_interceptors(null_interceptor): + transport = transports.BackupForGKERestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.BackupForGKERestInterceptor(), + ) + client = BackupForGKEClient(transport=transport) + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.BackupForGKERestInterceptor, "post_get_volume_restore" + ) as post, mock.patch.object( + transports.BackupForGKERestInterceptor, "pre_get_volume_restore" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + pb_message = gkebackup.GetVolumeRestoreRequest.pb( + gkebackup.GetVolumeRestoreRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = Response() + req.return_value.status_code = 200 + req.return_value.request = PreparedRequest() + req.return_value._content = volume.VolumeRestore.to_json(volume.VolumeRestore()) + + request = gkebackup.GetVolumeRestoreRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = volume.VolumeRestore() + + client.get_volume_restore( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + + +def test_get_volume_restore_rest_bad_request( + transport: str = "rest", request_type=gkebackup.GetVolumeRestoreRequest +): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # send a request that will satisfy transcoding + request_init = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4/volumeRestores/sample5" + } + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 400 + response_value.request = Request() + req.return_value = response_value + client.get_volume_restore(request) + + +def test_get_volume_restore_rest_flattened(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = volume.VolumeRestore() + + # get arguments that satisfy an http rule for this method + sample_request = { + "name": "projects/sample1/locations/sample2/restorePlans/sample3/restores/sample4/volumeRestores/sample5" + } + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + pb_return_value = volume.VolumeRestore.pb(return_value) + json_return_value = json_format.MessageToJson(pb_return_value) + response_value._content = json_return_value.encode("UTF-8") + req.return_value = response_value + + client.get_volume_restore(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=projects/*/locations/*/restorePlans/*/restores/*/volumeRestores/*}" + % client.transport._host, + args[1], + ) + + +def test_get_volume_restore_rest_flattened_error(transport: str = "rest"): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.get_volume_restore( + gkebackup.GetVolumeRestoreRequest(), + name="name_value", + ) + + +def test_get_volume_restore_rest_error(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + +def test_credentials_transport_error(): + # It is an error to provide credentials and a transport instance. + transport = transports.BackupForGKEGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # It is an error to provide a credentials file and a transport instance. + transport = transports.BackupForGKEGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = BackupForGKEClient( + client_options={"credentials_file": "credentials.json"}, + transport=transport, + ) + + # It is an error to provide an api_key and a transport instance. + transport = transports.BackupForGKEGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + options = client_options.ClientOptions() + options.api_key = "api_key" + with pytest.raises(ValueError): + client = BackupForGKEClient( + client_options=options, + transport=transport, + ) + + # It is an error to provide an api_key and a credential. + options = mock.Mock() + options.api_key = "api_key" + with pytest.raises(ValueError): + client = BackupForGKEClient( + client_options=options, credentials=ga_credentials.AnonymousCredentials() + ) + + # It is an error to provide scopes and a transport instance. + transport = transports.BackupForGKEGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + with pytest.raises(ValueError): + client = BackupForGKEClient( + client_options={"scopes": ["1", "2"]}, + transport=transport, + ) + + +def test_transport_instance(): + # A client may be instantiated with a custom transport instance. + transport = transports.BackupForGKEGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + client = BackupForGKEClient(transport=transport) + assert client.transport is transport + + +def test_transport_get_channel(): + # A client may be instantiated with a custom transport instance. + transport = transports.BackupForGKEGrpcTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + transport = transports.BackupForGKEGrpcAsyncIOTransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + channel = transport.grpc_channel + assert channel + + +@pytest.mark.parametrize( + "transport_class", + [ + transports.BackupForGKEGrpcTransport, + transports.BackupForGKEGrpcAsyncIOTransport, + transports.BackupForGKERestTransport, + ], +) +def test_transport_adc(transport_class): + # Test default credentials are used if not provided. + with mock.patch.object(google.auth, "default") as adc: + adc.return_value = (ga_credentials.AnonymousCredentials(), None) + transport_class() + adc.assert_called_once() + + +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + "rest", + ], +) +def test_transport_kind(transport_name): + transport = BackupForGKEClient.get_transport_class(transport_name)( + credentials=ga_credentials.AnonymousCredentials(), + ) + assert transport.kind == transport_name + + +def test_transport_grpc_default(): + # A client should use the gRPC transport by default. + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + assert isinstance( + client.transport, + transports.BackupForGKEGrpcTransport, + ) + + +def test_backup_for_gke_base_transport_error(): + # Passing both a credentials object and credentials_file should raise an error + with pytest.raises(core_exceptions.DuplicateCredentialArgs): + transport = transports.BackupForGKETransport( + credentials=ga_credentials.AnonymousCredentials(), + credentials_file="credentials.json", + ) + + +def test_backup_for_gke_base_transport(): + # Instantiate the base transport. + with mock.patch( + "google.cloud.gke_backup_v1.services.backup_for_gke.transports.BackupForGKETransport.__init__" + ) as Transport: + Transport.return_value = None + transport = transports.BackupForGKETransport( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Every method on the transport should just blindly + # raise NotImplementedError. + methods = ( + "create_backup_plan", + "list_backup_plans", + "get_backup_plan", + "update_backup_plan", + "delete_backup_plan", + "create_backup", + "list_backups", + "get_backup", + "update_backup", + "delete_backup", + "list_volume_backups", + "get_volume_backup", + "create_restore_plan", + "list_restore_plans", + "get_restore_plan", + "update_restore_plan", + "delete_restore_plan", + "create_restore", + "list_restores", + "get_restore", + "update_restore", + "delete_restore", + "list_volume_restores", + "get_volume_restore", + ) + for method in methods: + with pytest.raises(NotImplementedError): + getattr(transport, method)(request=object()) + + with pytest.raises(NotImplementedError): + transport.close() + + # Additionally, the LRO client (a property) should + # also raise NotImplementedError + with pytest.raises(NotImplementedError): + transport.operations_client + + # Catch all for all remaining methods and properties + remainder = [ + "kind", + ] + for r in remainder: + with pytest.raises(NotImplementedError): + getattr(transport, r)() + + +def test_backup_for_gke_base_transport_with_credentials_file(): + # Instantiate the base transport with a credentials file + with mock.patch.object( + google.auth, "load_credentials_from_file", autospec=True + ) as load_creds, mock.patch( + "google.cloud.gke_backup_v1.services.backup_for_gke.transports.BackupForGKETransport._prep_wrapped_messages" + ) as Transport: + Transport.return_value = None + load_creds.return_value = (ga_credentials.AnonymousCredentials(), None) + transport = transports.BackupForGKETransport( + credentials_file="credentials.json", + quota_project_id="octopus", + ) + load_creds.assert_called_once_with( + "credentials.json", + scopes=None, + default_scopes=("https://www.googleapis.com/auth/cloud-platform",), + quota_project_id="octopus", + ) + + +def test_backup_for_gke_base_transport_with_adc(): + # Test the default credentials are used if credentials and credentials_file are None. + with mock.patch.object(google.auth, "default", autospec=True) as adc, mock.patch( + "google.cloud.gke_backup_v1.services.backup_for_gke.transports.BackupForGKETransport._prep_wrapped_messages" + ) as Transport: Transport.return_value = None adc.return_value = (ga_credentials.AnonymousCredentials(), None) transport = transports.BackupForGKETransport() @@ -8093,6 +15948,7 @@ def test_backup_for_gke_transport_auth_adc(transport_class): [ transports.BackupForGKEGrpcTransport, transports.BackupForGKEGrpcAsyncIOTransport, + transports.BackupForGKERestTransport, ], ) def test_backup_for_gke_transport_auth_gdch_credentials(transport_class): @@ -8187,11 +16043,40 @@ def test_backup_for_gke_grpc_transport_client_cert_source_for_mtls(transport_cla ) +def test_backup_for_gke_http_transport_client_cert_source_for_mtls(): + cred = ga_credentials.AnonymousCredentials() + with mock.patch( + "google.auth.transport.requests.AuthorizedSession.configure_mtls_channel" + ) as mock_configure_mtls_channel: + transports.BackupForGKERestTransport( + credentials=cred, client_cert_source_for_mtls=client_cert_source_callback + ) + mock_configure_mtls_channel.assert_called_once_with(client_cert_source_callback) + + +def test_backup_for_gke_rest_lro_client(): + client = BackupForGKEClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + transport = client.transport + + # Ensure that we have a api-core operations client. + assert isinstance( + transport.operations_client, + operations_v1.AbstractOperationsClient, + ) + + # Ensure that subsequent calls to the property send the exact same object. + assert transport.operations_client is transport.operations_client + + @pytest.mark.parametrize( "transport_name", [ "grpc", "grpc_asyncio", + "rest", ], ) def test_backup_for_gke_host_no_port(transport_name): @@ -8202,7 +16087,11 @@ def test_backup_for_gke_host_no_port(transport_name): ), transport=transport_name, ) - assert client.transport._host == ("gkebackup.googleapis.com:443") + assert client.transport._host == ( + "gkebackup.googleapis.com:443" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://gkebackup.googleapis.com" + ) @pytest.mark.parametrize( @@ -8210,6 +16099,7 @@ def test_backup_for_gke_host_no_port(transport_name): [ "grpc", "grpc_asyncio", + "rest", ], ) def test_backup_for_gke_host_with_port(transport_name): @@ -8220,7 +16110,102 @@ def test_backup_for_gke_host_with_port(transport_name): ), transport=transport_name, ) - assert client.transport._host == ("gkebackup.googleapis.com:8000") + assert client.transport._host == ( + "gkebackup.googleapis.com:8000" + if transport_name in ["grpc", "grpc_asyncio"] + else "https://gkebackup.googleapis.com:8000" + ) + + +@pytest.mark.parametrize( + "transport_name", + [ + "rest", + ], +) +def test_backup_for_gke_client_transport_session_collision(transport_name): + creds1 = ga_credentials.AnonymousCredentials() + creds2 = ga_credentials.AnonymousCredentials() + client1 = BackupForGKEClient( + credentials=creds1, + transport=transport_name, + ) + client2 = BackupForGKEClient( + credentials=creds2, + transport=transport_name, + ) + session1 = client1.transport.create_backup_plan._session + session2 = client2.transport.create_backup_plan._session + assert session1 != session2 + session1 = client1.transport.list_backup_plans._session + session2 = client2.transport.list_backup_plans._session + assert session1 != session2 + session1 = client1.transport.get_backup_plan._session + session2 = client2.transport.get_backup_plan._session + assert session1 != session2 + session1 = client1.transport.update_backup_plan._session + session2 = client2.transport.update_backup_plan._session + assert session1 != session2 + session1 = client1.transport.delete_backup_plan._session + session2 = client2.transport.delete_backup_plan._session + assert session1 != session2 + session1 = client1.transport.create_backup._session + session2 = client2.transport.create_backup._session + assert session1 != session2 + session1 = client1.transport.list_backups._session + session2 = client2.transport.list_backups._session + assert session1 != session2 + session1 = client1.transport.get_backup._session + session2 = client2.transport.get_backup._session + assert session1 != session2 + session1 = client1.transport.update_backup._session + session2 = client2.transport.update_backup._session + assert session1 != session2 + session1 = client1.transport.delete_backup._session + session2 = client2.transport.delete_backup._session + assert session1 != session2 + session1 = client1.transport.list_volume_backups._session + session2 = client2.transport.list_volume_backups._session + assert session1 != session2 + session1 = client1.transport.get_volume_backup._session + session2 = client2.transport.get_volume_backup._session + assert session1 != session2 + session1 = client1.transport.create_restore_plan._session + session2 = client2.transport.create_restore_plan._session + assert session1 != session2 + session1 = client1.transport.list_restore_plans._session + session2 = client2.transport.list_restore_plans._session + assert session1 != session2 + session1 = client1.transport.get_restore_plan._session + session2 = client2.transport.get_restore_plan._session + assert session1 != session2 + session1 = client1.transport.update_restore_plan._session + session2 = client2.transport.update_restore_plan._session + assert session1 != session2 + session1 = client1.transport.delete_restore_plan._session + session2 = client2.transport.delete_restore_plan._session + assert session1 != session2 + session1 = client1.transport.create_restore._session + session2 = client2.transport.create_restore._session + assert session1 != session2 + session1 = client1.transport.list_restores._session + session2 = client2.transport.list_restores._session + assert session1 != session2 + session1 = client1.transport.get_restore._session + session2 = client2.transport.get_restore._session + assert session1 != session2 + session1 = client1.transport.update_restore._session + session2 = client2.transport.update_restore._session + assert session1 != session2 + session1 = client1.transport.delete_restore._session + session2 = client2.transport.delete_restore._session + assert session1 != session2 + session1 = client1.transport.list_volume_restores._session + session2 = client2.transport.list_volume_restores._session + assert session1 != session2 + session1 = client1.transport.get_volume_restore._session + session2 = client2.transport.get_volume_restore._session + assert session1 != session2 def test_backup_for_gke_grpc_transport_channel(): @@ -8754,6 +16739,7 @@ async def test_transport_close_async(): def test_transport_close(): transports = { + "rest": "_session", "grpc": "_grpc_channel", } @@ -8771,6 +16757,7 @@ def test_transport_close(): def test_client_ctx(): transports = [ + "rest", "grpc", ] for transport in transports: