Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1# -*- coding: utf-8 -*-
2# Copyright 2026 Google LLC
3#
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8# http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15#
16import dataclasses
17import json # type: ignore
18import logging
19import warnings
20from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
22import google.iam.v1.iam_policy_pb2 as iam_policy_pb2 # type: ignore
23import google.iam.v1.policy_pb2 as policy_pb2 # type: ignore
24import google.protobuf
25import google.protobuf.empty_pb2 as empty_pb2 # type: ignore
26from google.api_core import exceptions as core_exceptions
27from google.api_core import gapic_v1, rest_helpers, rest_streaming
28from google.api_core import retry as retries
29from google.auth import credentials as ga_credentials # type: ignore
30from google.auth.transport.requests import AuthorizedSession # type: ignore
31from google.cloud.location import locations_pb2 # type: ignore
32from google.protobuf import json_format
33from requests import __version__ as requests_version
35from google.cloud.secretmanager_v1beta1.types import resources, service
37from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO
38from .rest_base import _BaseSecretManagerServiceRestTransport
40try:
41 OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
42except AttributeError: # pragma: NO COVER
43 OptionalRetry = Union[retries.Retry, object, None] # type: ignore
45try:
46 from google.api_core import client_logging # type: ignore
48 CLIENT_LOGGING_SUPPORTED = True # pragma: NO COVER
49except ImportError: # pragma: NO COVER
50 CLIENT_LOGGING_SUPPORTED = False
52_LOGGER = logging.getLogger(__name__)
54DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
55 gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
56 grpc_version=None,
57 rest_version=f"requests@{requests_version}",
58)
60if hasattr(DEFAULT_CLIENT_INFO, "protobuf_runtime_version"): # pragma: NO COVER
61 DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__
64class SecretManagerServiceRestInterceptor:
65 """Interceptor for SecretManagerService.
67 Interceptors are used to manipulate requests, request metadata, and responses
68 in arbitrary ways.
69 Example use cases include:
70 * Logging
71 * Verifying requests according to service or custom semantics
72 * Stripping extraneous information from responses
74 These use cases and more can be enabled by injecting an
75 instance of a custom subclass when constructing the SecretManagerServiceRestTransport.
77 .. code-block:: python
78 class MyCustomSecretManagerServiceInterceptor(SecretManagerServiceRestInterceptor):
79 def pre_access_secret_version(self, request, metadata):
80 logging.log(f"Received request: {request}")
81 return request, metadata
83 def post_access_secret_version(self, response):
84 logging.log(f"Received response: {response}")
85 return response
87 def pre_add_secret_version(self, request, metadata):
88 logging.log(f"Received request: {request}")
89 return request, metadata
91 def post_add_secret_version(self, response):
92 logging.log(f"Received response: {response}")
93 return response
95 def pre_create_secret(self, request, metadata):
96 logging.log(f"Received request: {request}")
97 return request, metadata
99 def post_create_secret(self, response):
100 logging.log(f"Received response: {response}")
101 return response
103 def pre_delete_secret(self, request, metadata):
104 logging.log(f"Received request: {request}")
105 return request, metadata
107 def pre_destroy_secret_version(self, request, metadata):
108 logging.log(f"Received request: {request}")
109 return request, metadata
111 def post_destroy_secret_version(self, response):
112 logging.log(f"Received response: {response}")
113 return response
115 def pre_disable_secret_version(self, request, metadata):
116 logging.log(f"Received request: {request}")
117 return request, metadata
119 def post_disable_secret_version(self, response):
120 logging.log(f"Received response: {response}")
121 return response
123 def pre_enable_secret_version(self, request, metadata):
124 logging.log(f"Received request: {request}")
125 return request, metadata
127 def post_enable_secret_version(self, response):
128 logging.log(f"Received response: {response}")
129 return response
131 def pre_get_iam_policy(self, request, metadata):
132 logging.log(f"Received request: {request}")
133 return request, metadata
135 def post_get_iam_policy(self, response):
136 logging.log(f"Received response: {response}")
137 return response
139 def pre_get_secret(self, request, metadata):
140 logging.log(f"Received request: {request}")
141 return request, metadata
143 def post_get_secret(self, response):
144 logging.log(f"Received response: {response}")
145 return response
147 def pre_get_secret_version(self, request, metadata):
148 logging.log(f"Received request: {request}")
149 return request, metadata
151 def post_get_secret_version(self, response):
152 logging.log(f"Received response: {response}")
153 return response
155 def pre_list_secrets(self, request, metadata):
156 logging.log(f"Received request: {request}")
157 return request, metadata
159 def post_list_secrets(self, response):
160 logging.log(f"Received response: {response}")
161 return response
163 def pre_list_secret_versions(self, request, metadata):
164 logging.log(f"Received request: {request}")
165 return request, metadata
167 def post_list_secret_versions(self, response):
168 logging.log(f"Received response: {response}")
169 return response
171 def pre_set_iam_policy(self, request, metadata):
172 logging.log(f"Received request: {request}")
173 return request, metadata
175 def post_set_iam_policy(self, response):
176 logging.log(f"Received response: {response}")
177 return response
179 def pre_test_iam_permissions(self, request, metadata):
180 logging.log(f"Received request: {request}")
181 return request, metadata
183 def post_test_iam_permissions(self, response):
184 logging.log(f"Received response: {response}")
185 return response
187 def pre_update_secret(self, request, metadata):
188 logging.log(f"Received request: {request}")
189 return request, metadata
191 def post_update_secret(self, response):
192 logging.log(f"Received response: {response}")
193 return response
195 transport = SecretManagerServiceRestTransport(interceptor=MyCustomSecretManagerServiceInterceptor())
196 client = SecretManagerServiceClient(transport=transport)
199 """
201 def pre_access_secret_version(
202 self,
203 request: service.AccessSecretVersionRequest,
204 metadata: Sequence[Tuple[str, Union[str, bytes]]],
205 ) -> Tuple[
206 service.AccessSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
207 ]:
208 """Pre-rpc interceptor for access_secret_version
210 Override in a subclass to manipulate the request or metadata
211 before they are sent to the SecretManagerService server.
212 """
213 return request, metadata
215 def post_access_secret_version(
216 self, response: service.AccessSecretVersionResponse
217 ) -> service.AccessSecretVersionResponse:
218 """Post-rpc interceptor for access_secret_version
220 DEPRECATED. Please use the `post_access_secret_version_with_metadata`
221 interceptor instead.
223 Override in a subclass to read or manipulate the response
224 after it is returned by the SecretManagerService server but before
225 it is returned to user code. This `post_access_secret_version` interceptor runs
226 before the `post_access_secret_version_with_metadata` interceptor.
227 """
228 return response
230 def post_access_secret_version_with_metadata(
231 self,
232 response: service.AccessSecretVersionResponse,
233 metadata: Sequence[Tuple[str, Union[str, bytes]]],
234 ) -> Tuple[
235 service.AccessSecretVersionResponse, Sequence[Tuple[str, Union[str, bytes]]]
236 ]:
237 """Post-rpc interceptor for access_secret_version
239 Override in a subclass to read or manipulate the response or metadata after it
240 is returned by the SecretManagerService server but before it is returned to user code.
242 We recommend only using this `post_access_secret_version_with_metadata`
243 interceptor in new development instead of the `post_access_secret_version` interceptor.
244 When both interceptors are used, this `post_access_secret_version_with_metadata` interceptor runs after the
245 `post_access_secret_version` interceptor. The (possibly modified) response returned by
246 `post_access_secret_version` will be passed to
247 `post_access_secret_version_with_metadata`.
248 """
249 return response, metadata
251 def pre_add_secret_version(
252 self,
253 request: service.AddSecretVersionRequest,
254 metadata: Sequence[Tuple[str, Union[str, bytes]]],
255 ) -> Tuple[
256 service.AddSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
257 ]:
258 """Pre-rpc interceptor for add_secret_version
260 Override in a subclass to manipulate the request or metadata
261 before they are sent to the SecretManagerService server.
262 """
263 return request, metadata
265 def post_add_secret_version(
266 self, response: resources.SecretVersion
267 ) -> resources.SecretVersion:
268 """Post-rpc interceptor for add_secret_version
270 DEPRECATED. Please use the `post_add_secret_version_with_metadata`
271 interceptor instead.
273 Override in a subclass to read or manipulate the response
274 after it is returned by the SecretManagerService server but before
275 it is returned to user code. This `post_add_secret_version` interceptor runs
276 before the `post_add_secret_version_with_metadata` interceptor.
277 """
278 return response
280 def post_add_secret_version_with_metadata(
281 self,
282 response: resources.SecretVersion,
283 metadata: Sequence[Tuple[str, Union[str, bytes]]],
284 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
285 """Post-rpc interceptor for add_secret_version
287 Override in a subclass to read or manipulate the response or metadata after it
288 is returned by the SecretManagerService server but before it is returned to user code.
290 We recommend only using this `post_add_secret_version_with_metadata`
291 interceptor in new development instead of the `post_add_secret_version` interceptor.
292 When both interceptors are used, this `post_add_secret_version_with_metadata` interceptor runs after the
293 `post_add_secret_version` interceptor. The (possibly modified) response returned by
294 `post_add_secret_version` will be passed to
295 `post_add_secret_version_with_metadata`.
296 """
297 return response, metadata
299 def pre_create_secret(
300 self,
301 request: service.CreateSecretRequest,
302 metadata: Sequence[Tuple[str, Union[str, bytes]]],
303 ) -> Tuple[service.CreateSecretRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
304 """Pre-rpc interceptor for create_secret
306 Override in a subclass to manipulate the request or metadata
307 before they are sent to the SecretManagerService server.
308 """
309 return request, metadata
311 def post_create_secret(self, response: resources.Secret) -> resources.Secret:
312 """Post-rpc interceptor for create_secret
314 DEPRECATED. Please use the `post_create_secret_with_metadata`
315 interceptor instead.
317 Override in a subclass to read or manipulate the response
318 after it is returned by the SecretManagerService server but before
319 it is returned to user code. This `post_create_secret` interceptor runs
320 before the `post_create_secret_with_metadata` interceptor.
321 """
322 return response
324 def post_create_secret_with_metadata(
325 self,
326 response: resources.Secret,
327 metadata: Sequence[Tuple[str, Union[str, bytes]]],
328 ) -> Tuple[resources.Secret, Sequence[Tuple[str, Union[str, bytes]]]]:
329 """Post-rpc interceptor for create_secret
331 Override in a subclass to read or manipulate the response or metadata after it
332 is returned by the SecretManagerService server but before it is returned to user code.
334 We recommend only using this `post_create_secret_with_metadata`
335 interceptor in new development instead of the `post_create_secret` interceptor.
336 When both interceptors are used, this `post_create_secret_with_metadata` interceptor runs after the
337 `post_create_secret` interceptor. The (possibly modified) response returned by
338 `post_create_secret` will be passed to
339 `post_create_secret_with_metadata`.
340 """
341 return response, metadata
343 def pre_delete_secret(
344 self,
345 request: service.DeleteSecretRequest,
346 metadata: Sequence[Tuple[str, Union[str, bytes]]],
347 ) -> Tuple[service.DeleteSecretRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
348 """Pre-rpc interceptor for delete_secret
350 Override in a subclass to manipulate the request or metadata
351 before they are sent to the SecretManagerService server.
352 """
353 return request, metadata
355 def pre_destroy_secret_version(
356 self,
357 request: service.DestroySecretVersionRequest,
358 metadata: Sequence[Tuple[str, Union[str, bytes]]],
359 ) -> Tuple[
360 service.DestroySecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
361 ]:
362 """Pre-rpc interceptor for destroy_secret_version
364 Override in a subclass to manipulate the request or metadata
365 before they are sent to the SecretManagerService server.
366 """
367 return request, metadata
369 def post_destroy_secret_version(
370 self, response: resources.SecretVersion
371 ) -> resources.SecretVersion:
372 """Post-rpc interceptor for destroy_secret_version
374 DEPRECATED. Please use the `post_destroy_secret_version_with_metadata`
375 interceptor instead.
377 Override in a subclass to read or manipulate the response
378 after it is returned by the SecretManagerService server but before
379 it is returned to user code. This `post_destroy_secret_version` interceptor runs
380 before the `post_destroy_secret_version_with_metadata` interceptor.
381 """
382 return response
384 def post_destroy_secret_version_with_metadata(
385 self,
386 response: resources.SecretVersion,
387 metadata: Sequence[Tuple[str, Union[str, bytes]]],
388 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
389 """Post-rpc interceptor for destroy_secret_version
391 Override in a subclass to read or manipulate the response or metadata after it
392 is returned by the SecretManagerService server but before it is returned to user code.
394 We recommend only using this `post_destroy_secret_version_with_metadata`
395 interceptor in new development instead of the `post_destroy_secret_version` interceptor.
396 When both interceptors are used, this `post_destroy_secret_version_with_metadata` interceptor runs after the
397 `post_destroy_secret_version` interceptor. The (possibly modified) response returned by
398 `post_destroy_secret_version` will be passed to
399 `post_destroy_secret_version_with_metadata`.
400 """
401 return response, metadata
403 def pre_disable_secret_version(
404 self,
405 request: service.DisableSecretVersionRequest,
406 metadata: Sequence[Tuple[str, Union[str, bytes]]],
407 ) -> Tuple[
408 service.DisableSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
409 ]:
410 """Pre-rpc interceptor for disable_secret_version
412 Override in a subclass to manipulate the request or metadata
413 before they are sent to the SecretManagerService server.
414 """
415 return request, metadata
417 def post_disable_secret_version(
418 self, response: resources.SecretVersion
419 ) -> resources.SecretVersion:
420 """Post-rpc interceptor for disable_secret_version
422 DEPRECATED. Please use the `post_disable_secret_version_with_metadata`
423 interceptor instead.
425 Override in a subclass to read or manipulate the response
426 after it is returned by the SecretManagerService server but before
427 it is returned to user code. This `post_disable_secret_version` interceptor runs
428 before the `post_disable_secret_version_with_metadata` interceptor.
429 """
430 return response
432 def post_disable_secret_version_with_metadata(
433 self,
434 response: resources.SecretVersion,
435 metadata: Sequence[Tuple[str, Union[str, bytes]]],
436 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
437 """Post-rpc interceptor for disable_secret_version
439 Override in a subclass to read or manipulate the response or metadata after it
440 is returned by the SecretManagerService server but before it is returned to user code.
442 We recommend only using this `post_disable_secret_version_with_metadata`
443 interceptor in new development instead of the `post_disable_secret_version` interceptor.
444 When both interceptors are used, this `post_disable_secret_version_with_metadata` interceptor runs after the
445 `post_disable_secret_version` interceptor. The (possibly modified) response returned by
446 `post_disable_secret_version` will be passed to
447 `post_disable_secret_version_with_metadata`.
448 """
449 return response, metadata
451 def pre_enable_secret_version(
452 self,
453 request: service.EnableSecretVersionRequest,
454 metadata: Sequence[Tuple[str, Union[str, bytes]]],
455 ) -> Tuple[
456 service.EnableSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
457 ]:
458 """Pre-rpc interceptor for enable_secret_version
460 Override in a subclass to manipulate the request or metadata
461 before they are sent to the SecretManagerService server.
462 """
463 return request, metadata
465 def post_enable_secret_version(
466 self, response: resources.SecretVersion
467 ) -> resources.SecretVersion:
468 """Post-rpc interceptor for enable_secret_version
470 DEPRECATED. Please use the `post_enable_secret_version_with_metadata`
471 interceptor instead.
473 Override in a subclass to read or manipulate the response
474 after it is returned by the SecretManagerService server but before
475 it is returned to user code. This `post_enable_secret_version` interceptor runs
476 before the `post_enable_secret_version_with_metadata` interceptor.
477 """
478 return response
480 def post_enable_secret_version_with_metadata(
481 self,
482 response: resources.SecretVersion,
483 metadata: Sequence[Tuple[str, Union[str, bytes]]],
484 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
485 """Post-rpc interceptor for enable_secret_version
487 Override in a subclass to read or manipulate the response or metadata after it
488 is returned by the SecretManagerService server but before it is returned to user code.
490 We recommend only using this `post_enable_secret_version_with_metadata`
491 interceptor in new development instead of the `post_enable_secret_version` interceptor.
492 When both interceptors are used, this `post_enable_secret_version_with_metadata` interceptor runs after the
493 `post_enable_secret_version` interceptor. The (possibly modified) response returned by
494 `post_enable_secret_version` will be passed to
495 `post_enable_secret_version_with_metadata`.
496 """
497 return response, metadata
499 def pre_get_iam_policy(
500 self,
501 request: iam_policy_pb2.GetIamPolicyRequest,
502 metadata: Sequence[Tuple[str, Union[str, bytes]]],
503 ) -> Tuple[
504 iam_policy_pb2.GetIamPolicyRequest, Sequence[Tuple[str, Union[str, bytes]]]
505 ]:
506 """Pre-rpc interceptor for get_iam_policy
508 Override in a subclass to manipulate the request or metadata
509 before they are sent to the SecretManagerService server.
510 """
511 return request, metadata
513 def post_get_iam_policy(self, response: policy_pb2.Policy) -> policy_pb2.Policy:
514 """Post-rpc interceptor for get_iam_policy
516 DEPRECATED. Please use the `post_get_iam_policy_with_metadata`
517 interceptor instead.
519 Override in a subclass to read or manipulate the response
520 after it is returned by the SecretManagerService server but before
521 it is returned to user code. This `post_get_iam_policy` interceptor runs
522 before the `post_get_iam_policy_with_metadata` interceptor.
523 """
524 return response
526 def post_get_iam_policy_with_metadata(
527 self,
528 response: policy_pb2.Policy,
529 metadata: Sequence[Tuple[str, Union[str, bytes]]],
530 ) -> Tuple[policy_pb2.Policy, Sequence[Tuple[str, Union[str, bytes]]]]:
531 """Post-rpc interceptor for get_iam_policy
533 Override in a subclass to read or manipulate the response or metadata after it
534 is returned by the SecretManagerService server but before it is returned to user code.
536 We recommend only using this `post_get_iam_policy_with_metadata`
537 interceptor in new development instead of the `post_get_iam_policy` interceptor.
538 When both interceptors are used, this `post_get_iam_policy_with_metadata` interceptor runs after the
539 `post_get_iam_policy` interceptor. The (possibly modified) response returned by
540 `post_get_iam_policy` will be passed to
541 `post_get_iam_policy_with_metadata`.
542 """
543 return response, metadata
545 def pre_get_secret(
546 self,
547 request: service.GetSecretRequest,
548 metadata: Sequence[Tuple[str, Union[str, bytes]]],
549 ) -> Tuple[service.GetSecretRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
550 """Pre-rpc interceptor for get_secret
552 Override in a subclass to manipulate the request or metadata
553 before they are sent to the SecretManagerService server.
554 """
555 return request, metadata
557 def post_get_secret(self, response: resources.Secret) -> resources.Secret:
558 """Post-rpc interceptor for get_secret
560 DEPRECATED. Please use the `post_get_secret_with_metadata`
561 interceptor instead.
563 Override in a subclass to read or manipulate the response
564 after it is returned by the SecretManagerService server but before
565 it is returned to user code. This `post_get_secret` interceptor runs
566 before the `post_get_secret_with_metadata` interceptor.
567 """
568 return response
570 def post_get_secret_with_metadata(
571 self,
572 response: resources.Secret,
573 metadata: Sequence[Tuple[str, Union[str, bytes]]],
574 ) -> Tuple[resources.Secret, Sequence[Tuple[str, Union[str, bytes]]]]:
575 """Post-rpc interceptor for get_secret
577 Override in a subclass to read or manipulate the response or metadata after it
578 is returned by the SecretManagerService server but before it is returned to user code.
580 We recommend only using this `post_get_secret_with_metadata`
581 interceptor in new development instead of the `post_get_secret` interceptor.
582 When both interceptors are used, this `post_get_secret_with_metadata` interceptor runs after the
583 `post_get_secret` interceptor. The (possibly modified) response returned by
584 `post_get_secret` will be passed to
585 `post_get_secret_with_metadata`.
586 """
587 return response, metadata
589 def pre_get_secret_version(
590 self,
591 request: service.GetSecretVersionRequest,
592 metadata: Sequence[Tuple[str, Union[str, bytes]]],
593 ) -> Tuple[
594 service.GetSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
595 ]:
596 """Pre-rpc interceptor for get_secret_version
598 Override in a subclass to manipulate the request or metadata
599 before they are sent to the SecretManagerService server.
600 """
601 return request, metadata
603 def post_get_secret_version(
604 self, response: resources.SecretVersion
605 ) -> resources.SecretVersion:
606 """Post-rpc interceptor for get_secret_version
608 DEPRECATED. Please use the `post_get_secret_version_with_metadata`
609 interceptor instead.
611 Override in a subclass to read or manipulate the response
612 after it is returned by the SecretManagerService server but before
613 it is returned to user code. This `post_get_secret_version` interceptor runs
614 before the `post_get_secret_version_with_metadata` interceptor.
615 """
616 return response
618 def post_get_secret_version_with_metadata(
619 self,
620 response: resources.SecretVersion,
621 metadata: Sequence[Tuple[str, Union[str, bytes]]],
622 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
623 """Post-rpc interceptor for get_secret_version
625 Override in a subclass to read or manipulate the response or metadata after it
626 is returned by the SecretManagerService server but before it is returned to user code.
628 We recommend only using this `post_get_secret_version_with_metadata`
629 interceptor in new development instead of the `post_get_secret_version` interceptor.
630 When both interceptors are used, this `post_get_secret_version_with_metadata` interceptor runs after the
631 `post_get_secret_version` interceptor. The (possibly modified) response returned by
632 `post_get_secret_version` will be passed to
633 `post_get_secret_version_with_metadata`.
634 """
635 return response, metadata
637 def pre_list_secrets(
638 self,
639 request: service.ListSecretsRequest,
640 metadata: Sequence[Tuple[str, Union[str, bytes]]],
641 ) -> Tuple[service.ListSecretsRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
642 """Pre-rpc interceptor for list_secrets
644 Override in a subclass to manipulate the request or metadata
645 before they are sent to the SecretManagerService server.
646 """
647 return request, metadata
649 def post_list_secrets(
650 self, response: service.ListSecretsResponse
651 ) -> service.ListSecretsResponse:
652 """Post-rpc interceptor for list_secrets
654 DEPRECATED. Please use the `post_list_secrets_with_metadata`
655 interceptor instead.
657 Override in a subclass to read or manipulate the response
658 after it is returned by the SecretManagerService server but before
659 it is returned to user code. This `post_list_secrets` interceptor runs
660 before the `post_list_secrets_with_metadata` interceptor.
661 """
662 return response
664 def post_list_secrets_with_metadata(
665 self,
666 response: service.ListSecretsResponse,
667 metadata: Sequence[Tuple[str, Union[str, bytes]]],
668 ) -> Tuple[service.ListSecretsResponse, Sequence[Tuple[str, Union[str, bytes]]]]:
669 """Post-rpc interceptor for list_secrets
671 Override in a subclass to read or manipulate the response or metadata after it
672 is returned by the SecretManagerService server but before it is returned to user code.
674 We recommend only using this `post_list_secrets_with_metadata`
675 interceptor in new development instead of the `post_list_secrets` interceptor.
676 When both interceptors are used, this `post_list_secrets_with_metadata` interceptor runs after the
677 `post_list_secrets` interceptor. The (possibly modified) response returned by
678 `post_list_secrets` will be passed to
679 `post_list_secrets_with_metadata`.
680 """
681 return response, metadata
683 def pre_list_secret_versions(
684 self,
685 request: service.ListSecretVersionsRequest,
686 metadata: Sequence[Tuple[str, Union[str, bytes]]],
687 ) -> Tuple[
688 service.ListSecretVersionsRequest, Sequence[Tuple[str, Union[str, bytes]]]
689 ]:
690 """Pre-rpc interceptor for list_secret_versions
692 Override in a subclass to manipulate the request or metadata
693 before they are sent to the SecretManagerService server.
694 """
695 return request, metadata
697 def post_list_secret_versions(
698 self, response: service.ListSecretVersionsResponse
699 ) -> service.ListSecretVersionsResponse:
700 """Post-rpc interceptor for list_secret_versions
702 DEPRECATED. Please use the `post_list_secret_versions_with_metadata`
703 interceptor instead.
705 Override in a subclass to read or manipulate the response
706 after it is returned by the SecretManagerService server but before
707 it is returned to user code. This `post_list_secret_versions` interceptor runs
708 before the `post_list_secret_versions_with_metadata` interceptor.
709 """
710 return response
712 def post_list_secret_versions_with_metadata(
713 self,
714 response: service.ListSecretVersionsResponse,
715 metadata: Sequence[Tuple[str, Union[str, bytes]]],
716 ) -> Tuple[
717 service.ListSecretVersionsResponse, Sequence[Tuple[str, Union[str, bytes]]]
718 ]:
719 """Post-rpc interceptor for list_secret_versions
721 Override in a subclass to read or manipulate the response or metadata after it
722 is returned by the SecretManagerService server but before it is returned to user code.
724 We recommend only using this `post_list_secret_versions_with_metadata`
725 interceptor in new development instead of the `post_list_secret_versions` interceptor.
726 When both interceptors are used, this `post_list_secret_versions_with_metadata` interceptor runs after the
727 `post_list_secret_versions` interceptor. The (possibly modified) response returned by
728 `post_list_secret_versions` will be passed to
729 `post_list_secret_versions_with_metadata`.
730 """
731 return response, metadata
733 def pre_set_iam_policy(
734 self,
735 request: iam_policy_pb2.SetIamPolicyRequest,
736 metadata: Sequence[Tuple[str, Union[str, bytes]]],
737 ) -> Tuple[
738 iam_policy_pb2.SetIamPolicyRequest, Sequence[Tuple[str, Union[str, bytes]]]
739 ]:
740 """Pre-rpc interceptor for set_iam_policy
742 Override in a subclass to manipulate the request or metadata
743 before they are sent to the SecretManagerService server.
744 """
745 return request, metadata
747 def post_set_iam_policy(self, response: policy_pb2.Policy) -> policy_pb2.Policy:
748 """Post-rpc interceptor for set_iam_policy
750 DEPRECATED. Please use the `post_set_iam_policy_with_metadata`
751 interceptor instead.
753 Override in a subclass to read or manipulate the response
754 after it is returned by the SecretManagerService server but before
755 it is returned to user code. This `post_set_iam_policy` interceptor runs
756 before the `post_set_iam_policy_with_metadata` interceptor.
757 """
758 return response
760 def post_set_iam_policy_with_metadata(
761 self,
762 response: policy_pb2.Policy,
763 metadata: Sequence[Tuple[str, Union[str, bytes]]],
764 ) -> Tuple[policy_pb2.Policy, Sequence[Tuple[str, Union[str, bytes]]]]:
765 """Post-rpc interceptor for set_iam_policy
767 Override in a subclass to read or manipulate the response or metadata after it
768 is returned by the SecretManagerService server but before it is returned to user code.
770 We recommend only using this `post_set_iam_policy_with_metadata`
771 interceptor in new development instead of the `post_set_iam_policy` interceptor.
772 When both interceptors are used, this `post_set_iam_policy_with_metadata` interceptor runs after the
773 `post_set_iam_policy` interceptor. The (possibly modified) response returned by
774 `post_set_iam_policy` will be passed to
775 `post_set_iam_policy_with_metadata`.
776 """
777 return response, metadata
779 def pre_test_iam_permissions(
780 self,
781 request: iam_policy_pb2.TestIamPermissionsRequest,
782 metadata: Sequence[Tuple[str, Union[str, bytes]]],
783 ) -> Tuple[
784 iam_policy_pb2.TestIamPermissionsRequest,
785 Sequence[Tuple[str, Union[str, bytes]]],
786 ]:
787 """Pre-rpc interceptor for test_iam_permissions
789 Override in a subclass to manipulate the request or metadata
790 before they are sent to the SecretManagerService server.
791 """
792 return request, metadata
794 def post_test_iam_permissions(
795 self, response: iam_policy_pb2.TestIamPermissionsResponse
796 ) -> iam_policy_pb2.TestIamPermissionsResponse:
797 """Post-rpc interceptor for test_iam_permissions
799 DEPRECATED. Please use the `post_test_iam_permissions_with_metadata`
800 interceptor instead.
802 Override in a subclass to read or manipulate the response
803 after it is returned by the SecretManagerService server but before
804 it is returned to user code. This `post_test_iam_permissions` interceptor runs
805 before the `post_test_iam_permissions_with_metadata` interceptor.
806 """
807 return response
809 def post_test_iam_permissions_with_metadata(
810 self,
811 response: iam_policy_pb2.TestIamPermissionsResponse,
812 metadata: Sequence[Tuple[str, Union[str, bytes]]],
813 ) -> Tuple[
814 iam_policy_pb2.TestIamPermissionsResponse,
815 Sequence[Tuple[str, Union[str, bytes]]],
816 ]:
817 """Post-rpc interceptor for test_iam_permissions
819 Override in a subclass to read or manipulate the response or metadata after it
820 is returned by the SecretManagerService server but before it is returned to user code.
822 We recommend only using this `post_test_iam_permissions_with_metadata`
823 interceptor in new development instead of the `post_test_iam_permissions` interceptor.
824 When both interceptors are used, this `post_test_iam_permissions_with_metadata` interceptor runs after the
825 `post_test_iam_permissions` interceptor. The (possibly modified) response returned by
826 `post_test_iam_permissions` will be passed to
827 `post_test_iam_permissions_with_metadata`.
828 """
829 return response, metadata
831 def pre_update_secret(
832 self,
833 request: service.UpdateSecretRequest,
834 metadata: Sequence[Tuple[str, Union[str, bytes]]],
835 ) -> Tuple[service.UpdateSecretRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
836 """Pre-rpc interceptor for update_secret
838 Override in a subclass to manipulate the request or metadata
839 before they are sent to the SecretManagerService server.
840 """
841 return request, metadata
843 def post_update_secret(self, response: resources.Secret) -> resources.Secret:
844 """Post-rpc interceptor for update_secret
846 DEPRECATED. Please use the `post_update_secret_with_metadata`
847 interceptor instead.
849 Override in a subclass to read or manipulate the response
850 after it is returned by the SecretManagerService server but before
851 it is returned to user code. This `post_update_secret` interceptor runs
852 before the `post_update_secret_with_metadata` interceptor.
853 """
854 return response
856 def post_update_secret_with_metadata(
857 self,
858 response: resources.Secret,
859 metadata: Sequence[Tuple[str, Union[str, bytes]]],
860 ) -> Tuple[resources.Secret, Sequence[Tuple[str, Union[str, bytes]]]]:
861 """Post-rpc interceptor for update_secret
863 Override in a subclass to read or manipulate the response or metadata after it
864 is returned by the SecretManagerService server but before it is returned to user code.
866 We recommend only using this `post_update_secret_with_metadata`
867 interceptor in new development instead of the `post_update_secret` interceptor.
868 When both interceptors are used, this `post_update_secret_with_metadata` interceptor runs after the
869 `post_update_secret` interceptor. The (possibly modified) response returned by
870 `post_update_secret` will be passed to
871 `post_update_secret_with_metadata`.
872 """
873 return response, metadata
875 def pre_get_location(
876 self,
877 request: locations_pb2.GetLocationRequest,
878 metadata: Sequence[Tuple[str, Union[str, bytes]]],
879 ) -> Tuple[
880 locations_pb2.GetLocationRequest, Sequence[Tuple[str, Union[str, bytes]]]
881 ]:
882 """Pre-rpc interceptor for get_location
884 Override in a subclass to manipulate the request or metadata
885 before they are sent to the SecretManagerService server.
886 """
887 return request, metadata
889 def post_get_location(
890 self, response: locations_pb2.Location
891 ) -> locations_pb2.Location:
892 """Post-rpc interceptor for get_location
894 Override in a subclass to manipulate the response
895 after it is returned by the SecretManagerService server but before
896 it is returned to user code.
897 """
898 return response
900 def pre_list_locations(
901 self,
902 request: locations_pb2.ListLocationsRequest,
903 metadata: Sequence[Tuple[str, Union[str, bytes]]],
904 ) -> Tuple[
905 locations_pb2.ListLocationsRequest, Sequence[Tuple[str, Union[str, bytes]]]
906 ]:
907 """Pre-rpc interceptor for list_locations
909 Override in a subclass to manipulate the request or metadata
910 before they are sent to the SecretManagerService server.
911 """
912 return request, metadata
914 def post_list_locations(
915 self, response: locations_pb2.ListLocationsResponse
916 ) -> locations_pb2.ListLocationsResponse:
917 """Post-rpc interceptor for list_locations
919 Override in a subclass to manipulate the response
920 after it is returned by the SecretManagerService server but before
921 it is returned to user code.
922 """
923 return response
926@dataclasses.dataclass
927class SecretManagerServiceRestStub:
928 _session: AuthorizedSession
929 _host: str
930 _interceptor: SecretManagerServiceRestInterceptor
933class SecretManagerServiceRestTransport(_BaseSecretManagerServiceRestTransport):
934 """REST backend synchronous transport for SecretManagerService.
936 Secret Manager Service
938 Manages secrets and operations using those secrets. Implements a
939 REST model with the following objects:
941 - [Secret][google.cloud.secrets.v1beta1.Secret]
942 - [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]
944 This class defines the same methods as the primary client, so the
945 primary client can load the underlying transport implementation
946 and call it.
948 It sends JSON representations of protocol buffers over HTTP/1.1
949 """
951 def __init__(
952 self,
953 *,
954 host: str = "secretmanager.googleapis.com",
955 credentials: Optional[ga_credentials.Credentials] = None,
956 credentials_file: Optional[str] = None,
957 scopes: Optional[Sequence[str]] = None,
958 client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
959 quota_project_id: Optional[str] = None,
960 client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
961 always_use_jwt_access: Optional[bool] = False,
962 url_scheme: str = "https",
963 interceptor: Optional[SecretManagerServiceRestInterceptor] = None,
964 api_audience: Optional[str] = None,
965 ) -> None:
966 """Instantiate the transport.
968 Args:
969 host (Optional[str]):
970 The hostname to connect to (default: 'secretmanager.googleapis.com').
971 credentials (Optional[google.auth.credentials.Credentials]): The
972 authorization credentials to attach to requests. These
973 credentials identify the application to the service; if none
974 are specified, the client will attempt to ascertain the
975 credentials from the environment.
977 credentials_file (Optional[str]): Deprecated. A file with credentials that can
978 be loaded with :func:`google.auth.load_credentials_from_file`.
979 This argument is ignored if ``channel`` is provided. This argument will be
980 removed in the next major version of this library.
981 scopes (Optional(Sequence[str])): A list of scopes. This argument is
982 ignored if ``channel`` is provided.
983 client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
984 certificate to configure mutual TLS HTTP channel. It is ignored
985 if ``channel`` is provided.
986 quota_project_id (Optional[str]): An optional project to use for billing
987 and quota.
988 client_info (google.api_core.gapic_v1.client_info.ClientInfo):
989 The client info used to send a user-agent string along with
990 API requests. If ``None``, then default info will be used.
991 Generally, you only need to set this if you are developing
992 your own client library.
993 always_use_jwt_access (Optional[bool]): Whether self signed JWT should
994 be used for service account credentials.
995 url_scheme: the protocol scheme for the API endpoint. Normally
996 "https", but for testing or local servers,
997 "http" can be specified.
998 interceptor (Optional[SecretManagerServiceRestInterceptor]): Interceptor used
999 to manipulate requests, request metadata, and responses.
1000 api_audience (Optional[str]): The intended audience for the API calls
1001 to the service that will be set when using certain 3rd party
1002 authentication flows. Audience is typically a resource identifier.
1003 If not set, the host value will be used as a default.
1004 """
1005 # Run the base constructor
1006 # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
1007 # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
1008 # credentials object
1009 super().__init__(
1010 host=host,
1011 credentials=credentials,
1012 client_info=client_info,
1013 always_use_jwt_access=always_use_jwt_access,
1014 url_scheme=url_scheme,
1015 api_audience=api_audience,
1016 )
1017 self._session = AuthorizedSession(
1018 self._credentials, default_host=self.DEFAULT_HOST
1019 )
1020 if client_cert_source_for_mtls:
1021 self._session.configure_mtls_channel(client_cert_source_for_mtls)
1022 self._interceptor = interceptor or SecretManagerServiceRestInterceptor()
1023 self._prep_wrapped_messages(client_info)
1025 class _AccessSecretVersion(
1026 _BaseSecretManagerServiceRestTransport._BaseAccessSecretVersion,
1027 SecretManagerServiceRestStub,
1028 ):
1029 def __hash__(self):
1030 return hash("SecretManagerServiceRestTransport.AccessSecretVersion")
1032 @staticmethod
1033 def _get_response(
1034 host,
1035 metadata,
1036 query_params,
1037 session,
1038 timeout,
1039 transcoded_request,
1040 body=None,
1041 ):
1042 uri = transcoded_request["uri"]
1043 method = transcoded_request["method"]
1044 headers = dict(metadata)
1045 headers["Content-Type"] = "application/json"
1046 response = getattr(session, method)(
1047 "{host}{uri}".format(host=host, uri=uri),
1048 timeout=timeout,
1049 headers=headers,
1050 params=rest_helpers.flatten_query_params(query_params, strict=True),
1051 )
1052 return response
1054 def __call__(
1055 self,
1056 request: service.AccessSecretVersionRequest,
1057 *,
1058 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1059 timeout: Optional[float] = None,
1060 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1061 ) -> service.AccessSecretVersionResponse:
1062 r"""Call the access secret version method over HTTP.
1064 Args:
1065 request (~.service.AccessSecretVersionRequest):
1066 The request object. Request message for
1067 [SecretManagerService.AccessSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.AccessSecretVersion].
1068 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1069 should be retried.
1070 timeout (float): The timeout for this request.
1071 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1072 sent along with the request as metadata. Normally, each value must be of type `str`,
1073 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1074 be of type `bytes`.
1076 Returns:
1077 ~.service.AccessSecretVersionResponse:
1078 Response message for
1079 [SecretManagerService.AccessSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.AccessSecretVersion].
1081 """
1083 http_options = _BaseSecretManagerServiceRestTransport._BaseAccessSecretVersion._get_http_options()
1085 request, metadata = self._interceptor.pre_access_secret_version(
1086 request, metadata
1087 )
1088 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseAccessSecretVersion._get_transcoded_request(
1089 http_options, request
1090 )
1092 # Jsonify the query params
1093 query_params = _BaseSecretManagerServiceRestTransport._BaseAccessSecretVersion._get_query_params_json(
1094 transcoded_request
1095 )
1097 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1098 logging.DEBUG
1099 ): # pragma: NO COVER
1100 request_url = "{host}{uri}".format(
1101 host=self._host, uri=transcoded_request["uri"]
1102 )
1103 method = transcoded_request["method"]
1104 try:
1105 request_payload = type(request).to_json(request)
1106 except:
1107 request_payload = None
1108 http_request = {
1109 "payload": request_payload,
1110 "requestMethod": method,
1111 "requestUrl": request_url,
1112 "headers": dict(metadata),
1113 }
1114 _LOGGER.debug(
1115 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.AccessSecretVersion",
1116 extra={
1117 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1118 "rpcName": "AccessSecretVersion",
1119 "httpRequest": http_request,
1120 "metadata": http_request["headers"],
1121 },
1122 )
1124 # Send the request
1125 response = (
1126 SecretManagerServiceRestTransport._AccessSecretVersion._get_response(
1127 self._host,
1128 metadata,
1129 query_params,
1130 self._session,
1131 timeout,
1132 transcoded_request,
1133 )
1134 )
1136 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1137 # subclass.
1138 if response.status_code >= 400:
1139 raise core_exceptions.from_http_response(response)
1141 # Return the response
1142 resp = service.AccessSecretVersionResponse()
1143 pb_resp = service.AccessSecretVersionResponse.pb(resp)
1145 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1147 resp = self._interceptor.post_access_secret_version(resp)
1148 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1149 resp, _ = self._interceptor.post_access_secret_version_with_metadata(
1150 resp, response_metadata
1151 )
1152 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1153 logging.DEBUG
1154 ): # pragma: NO COVER
1155 try:
1156 response_payload = service.AccessSecretVersionResponse.to_json(
1157 response
1158 )
1159 except:
1160 response_payload = None
1161 http_response = {
1162 "payload": response_payload,
1163 "headers": dict(response.headers),
1164 "status": response.status_code,
1165 }
1166 _LOGGER.debug(
1167 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.access_secret_version",
1168 extra={
1169 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1170 "rpcName": "AccessSecretVersion",
1171 "metadata": http_response["headers"],
1172 "httpResponse": http_response,
1173 },
1174 )
1175 return resp
1177 class _AddSecretVersion(
1178 _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion,
1179 SecretManagerServiceRestStub,
1180 ):
1181 def __hash__(self):
1182 return hash("SecretManagerServiceRestTransport.AddSecretVersion")
1184 @staticmethod
1185 def _get_response(
1186 host,
1187 metadata,
1188 query_params,
1189 session,
1190 timeout,
1191 transcoded_request,
1192 body=None,
1193 ):
1194 uri = transcoded_request["uri"]
1195 method = transcoded_request["method"]
1196 headers = dict(metadata)
1197 headers["Content-Type"] = "application/json"
1198 response = getattr(session, method)(
1199 "{host}{uri}".format(host=host, uri=uri),
1200 timeout=timeout,
1201 headers=headers,
1202 params=rest_helpers.flatten_query_params(query_params, strict=True),
1203 data=body,
1204 )
1205 return response
1207 def __call__(
1208 self,
1209 request: service.AddSecretVersionRequest,
1210 *,
1211 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1212 timeout: Optional[float] = None,
1213 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1214 ) -> resources.SecretVersion:
1215 r"""Call the add secret version method over HTTP.
1217 Args:
1218 request (~.service.AddSecretVersionRequest):
1219 The request object. Request message for
1220 [SecretManagerService.AddSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.AddSecretVersion].
1221 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1222 should be retried.
1223 timeout (float): The timeout for this request.
1224 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1225 sent along with the request as metadata. Normally, each value must be of type `str`,
1226 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1227 be of type `bytes`.
1229 Returns:
1230 ~.resources.SecretVersion:
1231 A secret version resource in the
1232 Secret Manager API.
1234 """
1236 http_options = _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion._get_http_options()
1238 request, metadata = self._interceptor.pre_add_secret_version(
1239 request, metadata
1240 )
1241 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion._get_transcoded_request(
1242 http_options, request
1243 )
1245 body = _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion._get_request_body_json(
1246 transcoded_request
1247 )
1249 # Jsonify the query params
1250 query_params = _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion._get_query_params_json(
1251 transcoded_request
1252 )
1254 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1255 logging.DEBUG
1256 ): # pragma: NO COVER
1257 request_url = "{host}{uri}".format(
1258 host=self._host, uri=transcoded_request["uri"]
1259 )
1260 method = transcoded_request["method"]
1261 try:
1262 request_payload = type(request).to_json(request)
1263 except:
1264 request_payload = None
1265 http_request = {
1266 "payload": request_payload,
1267 "requestMethod": method,
1268 "requestUrl": request_url,
1269 "headers": dict(metadata),
1270 }
1271 _LOGGER.debug(
1272 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.AddSecretVersion",
1273 extra={
1274 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1275 "rpcName": "AddSecretVersion",
1276 "httpRequest": http_request,
1277 "metadata": http_request["headers"],
1278 },
1279 )
1281 # Send the request
1282 response = (
1283 SecretManagerServiceRestTransport._AddSecretVersion._get_response(
1284 self._host,
1285 metadata,
1286 query_params,
1287 self._session,
1288 timeout,
1289 transcoded_request,
1290 body,
1291 )
1292 )
1294 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1295 # subclass.
1296 if response.status_code >= 400:
1297 raise core_exceptions.from_http_response(response)
1299 # Return the response
1300 resp = resources.SecretVersion()
1301 pb_resp = resources.SecretVersion.pb(resp)
1303 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1305 resp = self._interceptor.post_add_secret_version(resp)
1306 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1307 resp, _ = self._interceptor.post_add_secret_version_with_metadata(
1308 resp, response_metadata
1309 )
1310 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1311 logging.DEBUG
1312 ): # pragma: NO COVER
1313 try:
1314 response_payload = resources.SecretVersion.to_json(response)
1315 except:
1316 response_payload = None
1317 http_response = {
1318 "payload": response_payload,
1319 "headers": dict(response.headers),
1320 "status": response.status_code,
1321 }
1322 _LOGGER.debug(
1323 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.add_secret_version",
1324 extra={
1325 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1326 "rpcName": "AddSecretVersion",
1327 "metadata": http_response["headers"],
1328 "httpResponse": http_response,
1329 },
1330 )
1331 return resp
1333 class _CreateSecret(
1334 _BaseSecretManagerServiceRestTransport._BaseCreateSecret,
1335 SecretManagerServiceRestStub,
1336 ):
1337 def __hash__(self):
1338 return hash("SecretManagerServiceRestTransport.CreateSecret")
1340 @staticmethod
1341 def _get_response(
1342 host,
1343 metadata,
1344 query_params,
1345 session,
1346 timeout,
1347 transcoded_request,
1348 body=None,
1349 ):
1350 uri = transcoded_request["uri"]
1351 method = transcoded_request["method"]
1352 headers = dict(metadata)
1353 headers["Content-Type"] = "application/json"
1354 response = getattr(session, method)(
1355 "{host}{uri}".format(host=host, uri=uri),
1356 timeout=timeout,
1357 headers=headers,
1358 params=rest_helpers.flatten_query_params(query_params, strict=True),
1359 data=body,
1360 )
1361 return response
1363 def __call__(
1364 self,
1365 request: service.CreateSecretRequest,
1366 *,
1367 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1368 timeout: Optional[float] = None,
1369 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1370 ) -> resources.Secret:
1371 r"""Call the create secret method over HTTP.
1373 Args:
1374 request (~.service.CreateSecretRequest):
1375 The request object. Request message for
1376 [SecretManagerService.CreateSecret][google.cloud.secrets.v1beta1.SecretManagerService.CreateSecret].
1377 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1378 should be retried.
1379 timeout (float): The timeout for this request.
1380 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1381 sent along with the request as metadata. Normally, each value must be of type `str`,
1382 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1383 be of type `bytes`.
1385 Returns:
1386 ~.resources.Secret:
1387 A [Secret][google.cloud.secrets.v1beta1.Secret] is a
1388 logical secret whose value and versions can be accessed.
1390 A [Secret][google.cloud.secrets.v1beta1.Secret] is made
1391 up of zero or more
1392 [SecretVersions][google.cloud.secrets.v1beta1.SecretVersion]
1393 that represent the secret data.
1395 """
1397 http_options = _BaseSecretManagerServiceRestTransport._BaseCreateSecret._get_http_options()
1399 request, metadata = self._interceptor.pre_create_secret(request, metadata)
1400 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseCreateSecret._get_transcoded_request(
1401 http_options, request
1402 )
1404 body = _BaseSecretManagerServiceRestTransport._BaseCreateSecret._get_request_body_json(
1405 transcoded_request
1406 )
1408 # Jsonify the query params
1409 query_params = _BaseSecretManagerServiceRestTransport._BaseCreateSecret._get_query_params_json(
1410 transcoded_request
1411 )
1413 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1414 logging.DEBUG
1415 ): # pragma: NO COVER
1416 request_url = "{host}{uri}".format(
1417 host=self._host, uri=transcoded_request["uri"]
1418 )
1419 method = transcoded_request["method"]
1420 try:
1421 request_payload = type(request).to_json(request)
1422 except:
1423 request_payload = None
1424 http_request = {
1425 "payload": request_payload,
1426 "requestMethod": method,
1427 "requestUrl": request_url,
1428 "headers": dict(metadata),
1429 }
1430 _LOGGER.debug(
1431 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.CreateSecret",
1432 extra={
1433 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1434 "rpcName": "CreateSecret",
1435 "httpRequest": http_request,
1436 "metadata": http_request["headers"],
1437 },
1438 )
1440 # Send the request
1441 response = SecretManagerServiceRestTransport._CreateSecret._get_response(
1442 self._host,
1443 metadata,
1444 query_params,
1445 self._session,
1446 timeout,
1447 transcoded_request,
1448 body,
1449 )
1451 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1452 # subclass.
1453 if response.status_code >= 400:
1454 raise core_exceptions.from_http_response(response)
1456 # Return the response
1457 resp = resources.Secret()
1458 pb_resp = resources.Secret.pb(resp)
1460 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1462 resp = self._interceptor.post_create_secret(resp)
1463 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1464 resp, _ = self._interceptor.post_create_secret_with_metadata(
1465 resp, response_metadata
1466 )
1467 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1468 logging.DEBUG
1469 ): # pragma: NO COVER
1470 try:
1471 response_payload = resources.Secret.to_json(response)
1472 except:
1473 response_payload = None
1474 http_response = {
1475 "payload": response_payload,
1476 "headers": dict(response.headers),
1477 "status": response.status_code,
1478 }
1479 _LOGGER.debug(
1480 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.create_secret",
1481 extra={
1482 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1483 "rpcName": "CreateSecret",
1484 "metadata": http_response["headers"],
1485 "httpResponse": http_response,
1486 },
1487 )
1488 return resp
1490 class _DeleteSecret(
1491 _BaseSecretManagerServiceRestTransport._BaseDeleteSecret,
1492 SecretManagerServiceRestStub,
1493 ):
1494 def __hash__(self):
1495 return hash("SecretManagerServiceRestTransport.DeleteSecret")
1497 @staticmethod
1498 def _get_response(
1499 host,
1500 metadata,
1501 query_params,
1502 session,
1503 timeout,
1504 transcoded_request,
1505 body=None,
1506 ):
1507 uri = transcoded_request["uri"]
1508 method = transcoded_request["method"]
1509 headers = dict(metadata)
1510 headers["Content-Type"] = "application/json"
1511 response = getattr(session, method)(
1512 "{host}{uri}".format(host=host, uri=uri),
1513 timeout=timeout,
1514 headers=headers,
1515 params=rest_helpers.flatten_query_params(query_params, strict=True),
1516 )
1517 return response
1519 def __call__(
1520 self,
1521 request: service.DeleteSecretRequest,
1522 *,
1523 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1524 timeout: Optional[float] = None,
1525 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1526 ):
1527 r"""Call the delete secret method over HTTP.
1529 Args:
1530 request (~.service.DeleteSecretRequest):
1531 The request object. Request message for
1532 [SecretManagerService.DeleteSecret][google.cloud.secrets.v1beta1.SecretManagerService.DeleteSecret].
1533 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1534 should be retried.
1535 timeout (float): The timeout for this request.
1536 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1537 sent along with the request as metadata. Normally, each value must be of type `str`,
1538 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1539 be of type `bytes`.
1540 """
1542 http_options = _BaseSecretManagerServiceRestTransport._BaseDeleteSecret._get_http_options()
1544 request, metadata = self._interceptor.pre_delete_secret(request, metadata)
1545 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseDeleteSecret._get_transcoded_request(
1546 http_options, request
1547 )
1549 # Jsonify the query params
1550 query_params = _BaseSecretManagerServiceRestTransport._BaseDeleteSecret._get_query_params_json(
1551 transcoded_request
1552 )
1554 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1555 logging.DEBUG
1556 ): # pragma: NO COVER
1557 request_url = "{host}{uri}".format(
1558 host=self._host, uri=transcoded_request["uri"]
1559 )
1560 method = transcoded_request["method"]
1561 try:
1562 request_payload = type(request).to_json(request)
1563 except:
1564 request_payload = None
1565 http_request = {
1566 "payload": request_payload,
1567 "requestMethod": method,
1568 "requestUrl": request_url,
1569 "headers": dict(metadata),
1570 }
1571 _LOGGER.debug(
1572 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.DeleteSecret",
1573 extra={
1574 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1575 "rpcName": "DeleteSecret",
1576 "httpRequest": http_request,
1577 "metadata": http_request["headers"],
1578 },
1579 )
1581 # Send the request
1582 response = SecretManagerServiceRestTransport._DeleteSecret._get_response(
1583 self._host,
1584 metadata,
1585 query_params,
1586 self._session,
1587 timeout,
1588 transcoded_request,
1589 )
1591 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1592 # subclass.
1593 if response.status_code >= 400:
1594 raise core_exceptions.from_http_response(response)
1596 class _DestroySecretVersion(
1597 _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion,
1598 SecretManagerServiceRestStub,
1599 ):
1600 def __hash__(self):
1601 return hash("SecretManagerServiceRestTransport.DestroySecretVersion")
1603 @staticmethod
1604 def _get_response(
1605 host,
1606 metadata,
1607 query_params,
1608 session,
1609 timeout,
1610 transcoded_request,
1611 body=None,
1612 ):
1613 uri = transcoded_request["uri"]
1614 method = transcoded_request["method"]
1615 headers = dict(metadata)
1616 headers["Content-Type"] = "application/json"
1617 response = getattr(session, method)(
1618 "{host}{uri}".format(host=host, uri=uri),
1619 timeout=timeout,
1620 headers=headers,
1621 params=rest_helpers.flatten_query_params(query_params, strict=True),
1622 data=body,
1623 )
1624 return response
1626 def __call__(
1627 self,
1628 request: service.DestroySecretVersionRequest,
1629 *,
1630 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1631 timeout: Optional[float] = None,
1632 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1633 ) -> resources.SecretVersion:
1634 r"""Call the destroy secret version method over HTTP.
1636 Args:
1637 request (~.service.DestroySecretVersionRequest):
1638 The request object. Request message for
1639 [SecretManagerService.DestroySecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.DestroySecretVersion].
1640 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1641 should be retried.
1642 timeout (float): The timeout for this request.
1643 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1644 sent along with the request as metadata. Normally, each value must be of type `str`,
1645 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1646 be of type `bytes`.
1648 Returns:
1649 ~.resources.SecretVersion:
1650 A secret version resource in the
1651 Secret Manager API.
1653 """
1655 http_options = _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion._get_http_options()
1657 request, metadata = self._interceptor.pre_destroy_secret_version(
1658 request, metadata
1659 )
1660 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion._get_transcoded_request(
1661 http_options, request
1662 )
1664 body = _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion._get_request_body_json(
1665 transcoded_request
1666 )
1668 # Jsonify the query params
1669 query_params = _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion._get_query_params_json(
1670 transcoded_request
1671 )
1673 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1674 logging.DEBUG
1675 ): # pragma: NO COVER
1676 request_url = "{host}{uri}".format(
1677 host=self._host, uri=transcoded_request["uri"]
1678 )
1679 method = transcoded_request["method"]
1680 try:
1681 request_payload = type(request).to_json(request)
1682 except:
1683 request_payload = None
1684 http_request = {
1685 "payload": request_payload,
1686 "requestMethod": method,
1687 "requestUrl": request_url,
1688 "headers": dict(metadata),
1689 }
1690 _LOGGER.debug(
1691 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.DestroySecretVersion",
1692 extra={
1693 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1694 "rpcName": "DestroySecretVersion",
1695 "httpRequest": http_request,
1696 "metadata": http_request["headers"],
1697 },
1698 )
1700 # Send the request
1701 response = (
1702 SecretManagerServiceRestTransport._DestroySecretVersion._get_response(
1703 self._host,
1704 metadata,
1705 query_params,
1706 self._session,
1707 timeout,
1708 transcoded_request,
1709 body,
1710 )
1711 )
1713 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1714 # subclass.
1715 if response.status_code >= 400:
1716 raise core_exceptions.from_http_response(response)
1718 # Return the response
1719 resp = resources.SecretVersion()
1720 pb_resp = resources.SecretVersion.pb(resp)
1722 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1724 resp = self._interceptor.post_destroy_secret_version(resp)
1725 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1726 resp, _ = self._interceptor.post_destroy_secret_version_with_metadata(
1727 resp, response_metadata
1728 )
1729 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1730 logging.DEBUG
1731 ): # pragma: NO COVER
1732 try:
1733 response_payload = resources.SecretVersion.to_json(response)
1734 except:
1735 response_payload = None
1736 http_response = {
1737 "payload": response_payload,
1738 "headers": dict(response.headers),
1739 "status": response.status_code,
1740 }
1741 _LOGGER.debug(
1742 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.destroy_secret_version",
1743 extra={
1744 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1745 "rpcName": "DestroySecretVersion",
1746 "metadata": http_response["headers"],
1747 "httpResponse": http_response,
1748 },
1749 )
1750 return resp
1752 class _DisableSecretVersion(
1753 _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion,
1754 SecretManagerServiceRestStub,
1755 ):
1756 def __hash__(self):
1757 return hash("SecretManagerServiceRestTransport.DisableSecretVersion")
1759 @staticmethod
1760 def _get_response(
1761 host,
1762 metadata,
1763 query_params,
1764 session,
1765 timeout,
1766 transcoded_request,
1767 body=None,
1768 ):
1769 uri = transcoded_request["uri"]
1770 method = transcoded_request["method"]
1771 headers = dict(metadata)
1772 headers["Content-Type"] = "application/json"
1773 response = getattr(session, method)(
1774 "{host}{uri}".format(host=host, uri=uri),
1775 timeout=timeout,
1776 headers=headers,
1777 params=rest_helpers.flatten_query_params(query_params, strict=True),
1778 data=body,
1779 )
1780 return response
1782 def __call__(
1783 self,
1784 request: service.DisableSecretVersionRequest,
1785 *,
1786 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1787 timeout: Optional[float] = None,
1788 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1789 ) -> resources.SecretVersion:
1790 r"""Call the disable secret version method over HTTP.
1792 Args:
1793 request (~.service.DisableSecretVersionRequest):
1794 The request object. Request message for
1795 [SecretManagerService.DisableSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.DisableSecretVersion].
1796 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1797 should be retried.
1798 timeout (float): The timeout for this request.
1799 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1800 sent along with the request as metadata. Normally, each value must be of type `str`,
1801 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1802 be of type `bytes`.
1804 Returns:
1805 ~.resources.SecretVersion:
1806 A secret version resource in the
1807 Secret Manager API.
1809 """
1811 http_options = _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion._get_http_options()
1813 request, metadata = self._interceptor.pre_disable_secret_version(
1814 request, metadata
1815 )
1816 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion._get_transcoded_request(
1817 http_options, request
1818 )
1820 body = _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion._get_request_body_json(
1821 transcoded_request
1822 )
1824 # Jsonify the query params
1825 query_params = _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion._get_query_params_json(
1826 transcoded_request
1827 )
1829 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1830 logging.DEBUG
1831 ): # pragma: NO COVER
1832 request_url = "{host}{uri}".format(
1833 host=self._host, uri=transcoded_request["uri"]
1834 )
1835 method = transcoded_request["method"]
1836 try:
1837 request_payload = type(request).to_json(request)
1838 except:
1839 request_payload = None
1840 http_request = {
1841 "payload": request_payload,
1842 "requestMethod": method,
1843 "requestUrl": request_url,
1844 "headers": dict(metadata),
1845 }
1846 _LOGGER.debug(
1847 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.DisableSecretVersion",
1848 extra={
1849 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1850 "rpcName": "DisableSecretVersion",
1851 "httpRequest": http_request,
1852 "metadata": http_request["headers"],
1853 },
1854 )
1856 # Send the request
1857 response = (
1858 SecretManagerServiceRestTransport._DisableSecretVersion._get_response(
1859 self._host,
1860 metadata,
1861 query_params,
1862 self._session,
1863 timeout,
1864 transcoded_request,
1865 body,
1866 )
1867 )
1869 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1870 # subclass.
1871 if response.status_code >= 400:
1872 raise core_exceptions.from_http_response(response)
1874 # Return the response
1875 resp = resources.SecretVersion()
1876 pb_resp = resources.SecretVersion.pb(resp)
1878 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1880 resp = self._interceptor.post_disable_secret_version(resp)
1881 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1882 resp, _ = self._interceptor.post_disable_secret_version_with_metadata(
1883 resp, response_metadata
1884 )
1885 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1886 logging.DEBUG
1887 ): # pragma: NO COVER
1888 try:
1889 response_payload = resources.SecretVersion.to_json(response)
1890 except:
1891 response_payload = None
1892 http_response = {
1893 "payload": response_payload,
1894 "headers": dict(response.headers),
1895 "status": response.status_code,
1896 }
1897 _LOGGER.debug(
1898 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.disable_secret_version",
1899 extra={
1900 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1901 "rpcName": "DisableSecretVersion",
1902 "metadata": http_response["headers"],
1903 "httpResponse": http_response,
1904 },
1905 )
1906 return resp
1908 class _EnableSecretVersion(
1909 _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion,
1910 SecretManagerServiceRestStub,
1911 ):
1912 def __hash__(self):
1913 return hash("SecretManagerServiceRestTransport.EnableSecretVersion")
1915 @staticmethod
1916 def _get_response(
1917 host,
1918 metadata,
1919 query_params,
1920 session,
1921 timeout,
1922 transcoded_request,
1923 body=None,
1924 ):
1925 uri = transcoded_request["uri"]
1926 method = transcoded_request["method"]
1927 headers = dict(metadata)
1928 headers["Content-Type"] = "application/json"
1929 response = getattr(session, method)(
1930 "{host}{uri}".format(host=host, uri=uri),
1931 timeout=timeout,
1932 headers=headers,
1933 params=rest_helpers.flatten_query_params(query_params, strict=True),
1934 data=body,
1935 )
1936 return response
1938 def __call__(
1939 self,
1940 request: service.EnableSecretVersionRequest,
1941 *,
1942 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1943 timeout: Optional[float] = None,
1944 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1945 ) -> resources.SecretVersion:
1946 r"""Call the enable secret version method over HTTP.
1948 Args:
1949 request (~.service.EnableSecretVersionRequest):
1950 The request object. Request message for
1951 [SecretManagerService.EnableSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.EnableSecretVersion].
1952 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1953 should be retried.
1954 timeout (float): The timeout for this request.
1955 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1956 sent along with the request as metadata. Normally, each value must be of type `str`,
1957 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1958 be of type `bytes`.
1960 Returns:
1961 ~.resources.SecretVersion:
1962 A secret version resource in the
1963 Secret Manager API.
1965 """
1967 http_options = _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion._get_http_options()
1969 request, metadata = self._interceptor.pre_enable_secret_version(
1970 request, metadata
1971 )
1972 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion._get_transcoded_request(
1973 http_options, request
1974 )
1976 body = _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion._get_request_body_json(
1977 transcoded_request
1978 )
1980 # Jsonify the query params
1981 query_params = _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion._get_query_params_json(
1982 transcoded_request
1983 )
1985 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1986 logging.DEBUG
1987 ): # pragma: NO COVER
1988 request_url = "{host}{uri}".format(
1989 host=self._host, uri=transcoded_request["uri"]
1990 )
1991 method = transcoded_request["method"]
1992 try:
1993 request_payload = type(request).to_json(request)
1994 except:
1995 request_payload = None
1996 http_request = {
1997 "payload": request_payload,
1998 "requestMethod": method,
1999 "requestUrl": request_url,
2000 "headers": dict(metadata),
2001 }
2002 _LOGGER.debug(
2003 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.EnableSecretVersion",
2004 extra={
2005 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2006 "rpcName": "EnableSecretVersion",
2007 "httpRequest": http_request,
2008 "metadata": http_request["headers"],
2009 },
2010 )
2012 # Send the request
2013 response = (
2014 SecretManagerServiceRestTransport._EnableSecretVersion._get_response(
2015 self._host,
2016 metadata,
2017 query_params,
2018 self._session,
2019 timeout,
2020 transcoded_request,
2021 body,
2022 )
2023 )
2025 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2026 # subclass.
2027 if response.status_code >= 400:
2028 raise core_exceptions.from_http_response(response)
2030 # Return the response
2031 resp = resources.SecretVersion()
2032 pb_resp = resources.SecretVersion.pb(resp)
2034 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2036 resp = self._interceptor.post_enable_secret_version(resp)
2037 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2038 resp, _ = self._interceptor.post_enable_secret_version_with_metadata(
2039 resp, response_metadata
2040 )
2041 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2042 logging.DEBUG
2043 ): # pragma: NO COVER
2044 try:
2045 response_payload = resources.SecretVersion.to_json(response)
2046 except:
2047 response_payload = None
2048 http_response = {
2049 "payload": response_payload,
2050 "headers": dict(response.headers),
2051 "status": response.status_code,
2052 }
2053 _LOGGER.debug(
2054 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.enable_secret_version",
2055 extra={
2056 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2057 "rpcName": "EnableSecretVersion",
2058 "metadata": http_response["headers"],
2059 "httpResponse": http_response,
2060 },
2061 )
2062 return resp
2064 class _GetIamPolicy(
2065 _BaseSecretManagerServiceRestTransport._BaseGetIamPolicy,
2066 SecretManagerServiceRestStub,
2067 ):
2068 def __hash__(self):
2069 return hash("SecretManagerServiceRestTransport.GetIamPolicy")
2071 @staticmethod
2072 def _get_response(
2073 host,
2074 metadata,
2075 query_params,
2076 session,
2077 timeout,
2078 transcoded_request,
2079 body=None,
2080 ):
2081 uri = transcoded_request["uri"]
2082 method = transcoded_request["method"]
2083 headers = dict(metadata)
2084 headers["Content-Type"] = "application/json"
2085 response = getattr(session, method)(
2086 "{host}{uri}".format(host=host, uri=uri),
2087 timeout=timeout,
2088 headers=headers,
2089 params=rest_helpers.flatten_query_params(query_params, strict=True),
2090 )
2091 return response
2093 def __call__(
2094 self,
2095 request: iam_policy_pb2.GetIamPolicyRequest,
2096 *,
2097 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2098 timeout: Optional[float] = None,
2099 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2100 ) -> policy_pb2.Policy:
2101 r"""Call the get iam policy method over HTTP.
2103 Args:
2104 request (~.iam_policy_pb2.GetIamPolicyRequest):
2105 The request object. Request message for ``GetIamPolicy`` method.
2106 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2107 should be retried.
2108 timeout (float): The timeout for this request.
2109 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2110 sent along with the request as metadata. Normally, each value must be of type `str`,
2111 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2112 be of type `bytes`.
2114 Returns:
2115 ~.policy_pb2.Policy:
2116 An Identity and Access Management (IAM) policy, which
2117 specifies access controls for Google Cloud resources.
2119 A ``Policy`` is a collection of ``bindings``. A
2120 ``binding`` binds one or more ``members``, or
2121 principals, to a single ``role``. Principals can be user
2122 accounts, service accounts, Google groups, and domains
2123 (such as G Suite). A ``role`` is a named list of
2124 permissions; each ``role`` can be an IAM predefined role
2125 or a user-created custom role.
2127 For some types of Google Cloud resources, a ``binding``
2128 can also specify a ``condition``, which is a logical
2129 expression that allows access to a resource only if the
2130 expression evaluates to ``true``. A condition can add
2131 constraints based on attributes of the request, the
2132 resource, or both. To learn which resources support
2133 conditions in their IAM policies, see the `IAM
2134 documentation <https://cloud.google.com/iam/help/conditions/resource-policies>`__.
2136 **JSON example:**
2138 ::
2140 {
2141 "bindings": [
2142 {
2143 "role": "roles/resourcemanager.organizationAdmin",
2144 "members": [
2145 "user:mike@example.com",
2146 "group:admins@example.com",
2147 "domain:google.com",
2148 "serviceAccount:my-project-id@appspot.gserviceaccount.com"
2149 ]
2150 },
2151 {
2152 "role": "roles/resourcemanager.organizationViewer",
2153 "members": [
2154 "user:eve@example.com"
2155 ],
2156 "condition": {
2157 "title": "expirable access",
2158 "description": "Does not grant access after Sep 2020",
2159 "expression": "request.time <
2160 timestamp('2020-10-01T00:00:00.000Z')",
2161 }
2162 }
2163 ],
2164 "etag": "BwWWja0YfJA=",
2165 "version": 3
2166 }
2168 **YAML example:**
2170 ::
2172 bindings:
2173 - members:
2174 - user:mike@example.com
2175 - group:admins@example.com
2176 - domain:google.com
2177 - serviceAccount:my-project-id@appspot.gserviceaccount.com
2178 role: roles/resourcemanager.organizationAdmin
2179 - members:
2180 - user:eve@example.com
2181 role: roles/resourcemanager.organizationViewer
2182 condition:
2183 title: expirable access
2184 description: Does not grant access after Sep 2020
2185 expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
2186 etag: BwWWja0YfJA=
2187 version: 3
2189 For a description of IAM and its features, see the `IAM
2190 documentation <https://cloud.google.com/iam/docs/>`__.
2192 """
2194 http_options = _BaseSecretManagerServiceRestTransport._BaseGetIamPolicy._get_http_options()
2196 request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
2197 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseGetIamPolicy._get_transcoded_request(
2198 http_options, request
2199 )
2201 # Jsonify the query params
2202 query_params = _BaseSecretManagerServiceRestTransport._BaseGetIamPolicy._get_query_params_json(
2203 transcoded_request
2204 )
2206 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2207 logging.DEBUG
2208 ): # pragma: NO COVER
2209 request_url = "{host}{uri}".format(
2210 host=self._host, uri=transcoded_request["uri"]
2211 )
2212 method = transcoded_request["method"]
2213 try:
2214 request_payload = json_format.MessageToJson(request)
2215 except:
2216 request_payload = None
2217 http_request = {
2218 "payload": request_payload,
2219 "requestMethod": method,
2220 "requestUrl": request_url,
2221 "headers": dict(metadata),
2222 }
2223 _LOGGER.debug(
2224 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.GetIamPolicy",
2225 extra={
2226 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2227 "rpcName": "GetIamPolicy",
2228 "httpRequest": http_request,
2229 "metadata": http_request["headers"],
2230 },
2231 )
2233 # Send the request
2234 response = SecretManagerServiceRestTransport._GetIamPolicy._get_response(
2235 self._host,
2236 metadata,
2237 query_params,
2238 self._session,
2239 timeout,
2240 transcoded_request,
2241 )
2243 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2244 # subclass.
2245 if response.status_code >= 400:
2246 raise core_exceptions.from_http_response(response)
2248 # Return the response
2249 resp = policy_pb2.Policy()
2250 pb_resp = resp
2252 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2254 resp = self._interceptor.post_get_iam_policy(resp)
2255 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2256 resp, _ = self._interceptor.post_get_iam_policy_with_metadata(
2257 resp, response_metadata
2258 )
2259 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2260 logging.DEBUG
2261 ): # pragma: NO COVER
2262 try:
2263 response_payload = json_format.MessageToJson(resp)
2264 except:
2265 response_payload = None
2266 http_response = {
2267 "payload": response_payload,
2268 "headers": dict(response.headers),
2269 "status": response.status_code,
2270 }
2271 _LOGGER.debug(
2272 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.get_iam_policy",
2273 extra={
2274 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2275 "rpcName": "GetIamPolicy",
2276 "metadata": http_response["headers"],
2277 "httpResponse": http_response,
2278 },
2279 )
2280 return resp
2282 class _GetSecret(
2283 _BaseSecretManagerServiceRestTransport._BaseGetSecret,
2284 SecretManagerServiceRestStub,
2285 ):
2286 def __hash__(self):
2287 return hash("SecretManagerServiceRestTransport.GetSecret")
2289 @staticmethod
2290 def _get_response(
2291 host,
2292 metadata,
2293 query_params,
2294 session,
2295 timeout,
2296 transcoded_request,
2297 body=None,
2298 ):
2299 uri = transcoded_request["uri"]
2300 method = transcoded_request["method"]
2301 headers = dict(metadata)
2302 headers["Content-Type"] = "application/json"
2303 response = getattr(session, method)(
2304 "{host}{uri}".format(host=host, uri=uri),
2305 timeout=timeout,
2306 headers=headers,
2307 params=rest_helpers.flatten_query_params(query_params, strict=True),
2308 )
2309 return response
2311 def __call__(
2312 self,
2313 request: service.GetSecretRequest,
2314 *,
2315 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2316 timeout: Optional[float] = None,
2317 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2318 ) -> resources.Secret:
2319 r"""Call the get secret method over HTTP.
2321 Args:
2322 request (~.service.GetSecretRequest):
2323 The request object. Request message for
2324 [SecretManagerService.GetSecret][google.cloud.secrets.v1beta1.SecretManagerService.GetSecret].
2325 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2326 should be retried.
2327 timeout (float): The timeout for this request.
2328 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2329 sent along with the request as metadata. Normally, each value must be of type `str`,
2330 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2331 be of type `bytes`.
2333 Returns:
2334 ~.resources.Secret:
2335 A [Secret][google.cloud.secrets.v1beta1.Secret] is a
2336 logical secret whose value and versions can be accessed.
2338 A [Secret][google.cloud.secrets.v1beta1.Secret] is made
2339 up of zero or more
2340 [SecretVersions][google.cloud.secrets.v1beta1.SecretVersion]
2341 that represent the secret data.
2343 """
2345 http_options = _BaseSecretManagerServiceRestTransport._BaseGetSecret._get_http_options()
2347 request, metadata = self._interceptor.pre_get_secret(request, metadata)
2348 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseGetSecret._get_transcoded_request(
2349 http_options, request
2350 )
2352 # Jsonify the query params
2353 query_params = _BaseSecretManagerServiceRestTransport._BaseGetSecret._get_query_params_json(
2354 transcoded_request
2355 )
2357 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2358 logging.DEBUG
2359 ): # pragma: NO COVER
2360 request_url = "{host}{uri}".format(
2361 host=self._host, uri=transcoded_request["uri"]
2362 )
2363 method = transcoded_request["method"]
2364 try:
2365 request_payload = type(request).to_json(request)
2366 except:
2367 request_payload = None
2368 http_request = {
2369 "payload": request_payload,
2370 "requestMethod": method,
2371 "requestUrl": request_url,
2372 "headers": dict(metadata),
2373 }
2374 _LOGGER.debug(
2375 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.GetSecret",
2376 extra={
2377 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2378 "rpcName": "GetSecret",
2379 "httpRequest": http_request,
2380 "metadata": http_request["headers"],
2381 },
2382 )
2384 # Send the request
2385 response = SecretManagerServiceRestTransport._GetSecret._get_response(
2386 self._host,
2387 metadata,
2388 query_params,
2389 self._session,
2390 timeout,
2391 transcoded_request,
2392 )
2394 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2395 # subclass.
2396 if response.status_code >= 400:
2397 raise core_exceptions.from_http_response(response)
2399 # Return the response
2400 resp = resources.Secret()
2401 pb_resp = resources.Secret.pb(resp)
2403 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2405 resp = self._interceptor.post_get_secret(resp)
2406 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2407 resp, _ = self._interceptor.post_get_secret_with_metadata(
2408 resp, response_metadata
2409 )
2410 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2411 logging.DEBUG
2412 ): # pragma: NO COVER
2413 try:
2414 response_payload = resources.Secret.to_json(response)
2415 except:
2416 response_payload = None
2417 http_response = {
2418 "payload": response_payload,
2419 "headers": dict(response.headers),
2420 "status": response.status_code,
2421 }
2422 _LOGGER.debug(
2423 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.get_secret",
2424 extra={
2425 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2426 "rpcName": "GetSecret",
2427 "metadata": http_response["headers"],
2428 "httpResponse": http_response,
2429 },
2430 )
2431 return resp
2433 class _GetSecretVersion(
2434 _BaseSecretManagerServiceRestTransport._BaseGetSecretVersion,
2435 SecretManagerServiceRestStub,
2436 ):
2437 def __hash__(self):
2438 return hash("SecretManagerServiceRestTransport.GetSecretVersion")
2440 @staticmethod
2441 def _get_response(
2442 host,
2443 metadata,
2444 query_params,
2445 session,
2446 timeout,
2447 transcoded_request,
2448 body=None,
2449 ):
2450 uri = transcoded_request["uri"]
2451 method = transcoded_request["method"]
2452 headers = dict(metadata)
2453 headers["Content-Type"] = "application/json"
2454 response = getattr(session, method)(
2455 "{host}{uri}".format(host=host, uri=uri),
2456 timeout=timeout,
2457 headers=headers,
2458 params=rest_helpers.flatten_query_params(query_params, strict=True),
2459 )
2460 return response
2462 def __call__(
2463 self,
2464 request: service.GetSecretVersionRequest,
2465 *,
2466 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2467 timeout: Optional[float] = None,
2468 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2469 ) -> resources.SecretVersion:
2470 r"""Call the get secret version method over HTTP.
2472 Args:
2473 request (~.service.GetSecretVersionRequest):
2474 The request object. Request message for
2475 [SecretManagerService.GetSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.GetSecretVersion].
2476 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2477 should be retried.
2478 timeout (float): The timeout for this request.
2479 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2480 sent along with the request as metadata. Normally, each value must be of type `str`,
2481 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2482 be of type `bytes`.
2484 Returns:
2485 ~.resources.SecretVersion:
2486 A secret version resource in the
2487 Secret Manager API.
2489 """
2491 http_options = _BaseSecretManagerServiceRestTransport._BaseGetSecretVersion._get_http_options()
2493 request, metadata = self._interceptor.pre_get_secret_version(
2494 request, metadata
2495 )
2496 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseGetSecretVersion._get_transcoded_request(
2497 http_options, request
2498 )
2500 # Jsonify the query params
2501 query_params = _BaseSecretManagerServiceRestTransport._BaseGetSecretVersion._get_query_params_json(
2502 transcoded_request
2503 )
2505 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2506 logging.DEBUG
2507 ): # pragma: NO COVER
2508 request_url = "{host}{uri}".format(
2509 host=self._host, uri=transcoded_request["uri"]
2510 )
2511 method = transcoded_request["method"]
2512 try:
2513 request_payload = type(request).to_json(request)
2514 except:
2515 request_payload = None
2516 http_request = {
2517 "payload": request_payload,
2518 "requestMethod": method,
2519 "requestUrl": request_url,
2520 "headers": dict(metadata),
2521 }
2522 _LOGGER.debug(
2523 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.GetSecretVersion",
2524 extra={
2525 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2526 "rpcName": "GetSecretVersion",
2527 "httpRequest": http_request,
2528 "metadata": http_request["headers"],
2529 },
2530 )
2532 # Send the request
2533 response = (
2534 SecretManagerServiceRestTransport._GetSecretVersion._get_response(
2535 self._host,
2536 metadata,
2537 query_params,
2538 self._session,
2539 timeout,
2540 transcoded_request,
2541 )
2542 )
2544 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2545 # subclass.
2546 if response.status_code >= 400:
2547 raise core_exceptions.from_http_response(response)
2549 # Return the response
2550 resp = resources.SecretVersion()
2551 pb_resp = resources.SecretVersion.pb(resp)
2553 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2555 resp = self._interceptor.post_get_secret_version(resp)
2556 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2557 resp, _ = self._interceptor.post_get_secret_version_with_metadata(
2558 resp, response_metadata
2559 )
2560 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2561 logging.DEBUG
2562 ): # pragma: NO COVER
2563 try:
2564 response_payload = resources.SecretVersion.to_json(response)
2565 except:
2566 response_payload = None
2567 http_response = {
2568 "payload": response_payload,
2569 "headers": dict(response.headers),
2570 "status": response.status_code,
2571 }
2572 _LOGGER.debug(
2573 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.get_secret_version",
2574 extra={
2575 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2576 "rpcName": "GetSecretVersion",
2577 "metadata": http_response["headers"],
2578 "httpResponse": http_response,
2579 },
2580 )
2581 return resp
2583 class _ListSecrets(
2584 _BaseSecretManagerServiceRestTransport._BaseListSecrets,
2585 SecretManagerServiceRestStub,
2586 ):
2587 def __hash__(self):
2588 return hash("SecretManagerServiceRestTransport.ListSecrets")
2590 @staticmethod
2591 def _get_response(
2592 host,
2593 metadata,
2594 query_params,
2595 session,
2596 timeout,
2597 transcoded_request,
2598 body=None,
2599 ):
2600 uri = transcoded_request["uri"]
2601 method = transcoded_request["method"]
2602 headers = dict(metadata)
2603 headers["Content-Type"] = "application/json"
2604 response = getattr(session, method)(
2605 "{host}{uri}".format(host=host, uri=uri),
2606 timeout=timeout,
2607 headers=headers,
2608 params=rest_helpers.flatten_query_params(query_params, strict=True),
2609 )
2610 return response
2612 def __call__(
2613 self,
2614 request: service.ListSecretsRequest,
2615 *,
2616 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2617 timeout: Optional[float] = None,
2618 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2619 ) -> service.ListSecretsResponse:
2620 r"""Call the list secrets method over HTTP.
2622 Args:
2623 request (~.service.ListSecretsRequest):
2624 The request object. Request message for
2625 [SecretManagerService.ListSecrets][google.cloud.secrets.v1beta1.SecretManagerService.ListSecrets].
2626 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2627 should be retried.
2628 timeout (float): The timeout for this request.
2629 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2630 sent along with the request as metadata. Normally, each value must be of type `str`,
2631 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2632 be of type `bytes`.
2634 Returns:
2635 ~.service.ListSecretsResponse:
2636 Response message for
2637 [SecretManagerService.ListSecrets][google.cloud.secrets.v1beta1.SecretManagerService.ListSecrets].
2639 """
2641 http_options = _BaseSecretManagerServiceRestTransport._BaseListSecrets._get_http_options()
2643 request, metadata = self._interceptor.pre_list_secrets(request, metadata)
2644 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseListSecrets._get_transcoded_request(
2645 http_options, request
2646 )
2648 # Jsonify the query params
2649 query_params = _BaseSecretManagerServiceRestTransport._BaseListSecrets._get_query_params_json(
2650 transcoded_request
2651 )
2653 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2654 logging.DEBUG
2655 ): # pragma: NO COVER
2656 request_url = "{host}{uri}".format(
2657 host=self._host, uri=transcoded_request["uri"]
2658 )
2659 method = transcoded_request["method"]
2660 try:
2661 request_payload = type(request).to_json(request)
2662 except:
2663 request_payload = None
2664 http_request = {
2665 "payload": request_payload,
2666 "requestMethod": method,
2667 "requestUrl": request_url,
2668 "headers": dict(metadata),
2669 }
2670 _LOGGER.debug(
2671 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.ListSecrets",
2672 extra={
2673 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2674 "rpcName": "ListSecrets",
2675 "httpRequest": http_request,
2676 "metadata": http_request["headers"],
2677 },
2678 )
2680 # Send the request
2681 response = SecretManagerServiceRestTransport._ListSecrets._get_response(
2682 self._host,
2683 metadata,
2684 query_params,
2685 self._session,
2686 timeout,
2687 transcoded_request,
2688 )
2690 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2691 # subclass.
2692 if response.status_code >= 400:
2693 raise core_exceptions.from_http_response(response)
2695 # Return the response
2696 resp = service.ListSecretsResponse()
2697 pb_resp = service.ListSecretsResponse.pb(resp)
2699 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2701 resp = self._interceptor.post_list_secrets(resp)
2702 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2703 resp, _ = self._interceptor.post_list_secrets_with_metadata(
2704 resp, response_metadata
2705 )
2706 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2707 logging.DEBUG
2708 ): # pragma: NO COVER
2709 try:
2710 response_payload = service.ListSecretsResponse.to_json(response)
2711 except:
2712 response_payload = None
2713 http_response = {
2714 "payload": response_payload,
2715 "headers": dict(response.headers),
2716 "status": response.status_code,
2717 }
2718 _LOGGER.debug(
2719 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.list_secrets",
2720 extra={
2721 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2722 "rpcName": "ListSecrets",
2723 "metadata": http_response["headers"],
2724 "httpResponse": http_response,
2725 },
2726 )
2727 return resp
2729 class _ListSecretVersions(
2730 _BaseSecretManagerServiceRestTransport._BaseListSecretVersions,
2731 SecretManagerServiceRestStub,
2732 ):
2733 def __hash__(self):
2734 return hash("SecretManagerServiceRestTransport.ListSecretVersions")
2736 @staticmethod
2737 def _get_response(
2738 host,
2739 metadata,
2740 query_params,
2741 session,
2742 timeout,
2743 transcoded_request,
2744 body=None,
2745 ):
2746 uri = transcoded_request["uri"]
2747 method = transcoded_request["method"]
2748 headers = dict(metadata)
2749 headers["Content-Type"] = "application/json"
2750 response = getattr(session, method)(
2751 "{host}{uri}".format(host=host, uri=uri),
2752 timeout=timeout,
2753 headers=headers,
2754 params=rest_helpers.flatten_query_params(query_params, strict=True),
2755 )
2756 return response
2758 def __call__(
2759 self,
2760 request: service.ListSecretVersionsRequest,
2761 *,
2762 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2763 timeout: Optional[float] = None,
2764 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2765 ) -> service.ListSecretVersionsResponse:
2766 r"""Call the list secret versions method over HTTP.
2768 Args:
2769 request (~.service.ListSecretVersionsRequest):
2770 The request object. Request message for
2771 [SecretManagerService.ListSecretVersions][google.cloud.secrets.v1beta1.SecretManagerService.ListSecretVersions].
2772 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2773 should be retried.
2774 timeout (float): The timeout for this request.
2775 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2776 sent along with the request as metadata. Normally, each value must be of type `str`,
2777 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2778 be of type `bytes`.
2780 Returns:
2781 ~.service.ListSecretVersionsResponse:
2782 Response message for
2783 [SecretManagerService.ListSecretVersions][google.cloud.secrets.v1beta1.SecretManagerService.ListSecretVersions].
2785 """
2787 http_options = _BaseSecretManagerServiceRestTransport._BaseListSecretVersions._get_http_options()
2789 request, metadata = self._interceptor.pre_list_secret_versions(
2790 request, metadata
2791 )
2792 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseListSecretVersions._get_transcoded_request(
2793 http_options, request
2794 )
2796 # Jsonify the query params
2797 query_params = _BaseSecretManagerServiceRestTransport._BaseListSecretVersions._get_query_params_json(
2798 transcoded_request
2799 )
2801 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2802 logging.DEBUG
2803 ): # pragma: NO COVER
2804 request_url = "{host}{uri}".format(
2805 host=self._host, uri=transcoded_request["uri"]
2806 )
2807 method = transcoded_request["method"]
2808 try:
2809 request_payload = type(request).to_json(request)
2810 except:
2811 request_payload = None
2812 http_request = {
2813 "payload": request_payload,
2814 "requestMethod": method,
2815 "requestUrl": request_url,
2816 "headers": dict(metadata),
2817 }
2818 _LOGGER.debug(
2819 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.ListSecretVersions",
2820 extra={
2821 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2822 "rpcName": "ListSecretVersions",
2823 "httpRequest": http_request,
2824 "metadata": http_request["headers"],
2825 },
2826 )
2828 # Send the request
2829 response = (
2830 SecretManagerServiceRestTransport._ListSecretVersions._get_response(
2831 self._host,
2832 metadata,
2833 query_params,
2834 self._session,
2835 timeout,
2836 transcoded_request,
2837 )
2838 )
2840 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2841 # subclass.
2842 if response.status_code >= 400:
2843 raise core_exceptions.from_http_response(response)
2845 # Return the response
2846 resp = service.ListSecretVersionsResponse()
2847 pb_resp = service.ListSecretVersionsResponse.pb(resp)
2849 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2851 resp = self._interceptor.post_list_secret_versions(resp)
2852 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2853 resp, _ = self._interceptor.post_list_secret_versions_with_metadata(
2854 resp, response_metadata
2855 )
2856 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2857 logging.DEBUG
2858 ): # pragma: NO COVER
2859 try:
2860 response_payload = service.ListSecretVersionsResponse.to_json(
2861 response
2862 )
2863 except:
2864 response_payload = None
2865 http_response = {
2866 "payload": response_payload,
2867 "headers": dict(response.headers),
2868 "status": response.status_code,
2869 }
2870 _LOGGER.debug(
2871 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.list_secret_versions",
2872 extra={
2873 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2874 "rpcName": "ListSecretVersions",
2875 "metadata": http_response["headers"],
2876 "httpResponse": http_response,
2877 },
2878 )
2879 return resp
2881 class _SetIamPolicy(
2882 _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy,
2883 SecretManagerServiceRestStub,
2884 ):
2885 def __hash__(self):
2886 return hash("SecretManagerServiceRestTransport.SetIamPolicy")
2888 @staticmethod
2889 def _get_response(
2890 host,
2891 metadata,
2892 query_params,
2893 session,
2894 timeout,
2895 transcoded_request,
2896 body=None,
2897 ):
2898 uri = transcoded_request["uri"]
2899 method = transcoded_request["method"]
2900 headers = dict(metadata)
2901 headers["Content-Type"] = "application/json"
2902 response = getattr(session, method)(
2903 "{host}{uri}".format(host=host, uri=uri),
2904 timeout=timeout,
2905 headers=headers,
2906 params=rest_helpers.flatten_query_params(query_params, strict=True),
2907 data=body,
2908 )
2909 return response
2911 def __call__(
2912 self,
2913 request: iam_policy_pb2.SetIamPolicyRequest,
2914 *,
2915 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2916 timeout: Optional[float] = None,
2917 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2918 ) -> policy_pb2.Policy:
2919 r"""Call the set iam policy method over HTTP.
2921 Args:
2922 request (~.iam_policy_pb2.SetIamPolicyRequest):
2923 The request object. Request message for ``SetIamPolicy`` method.
2924 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2925 should be retried.
2926 timeout (float): The timeout for this request.
2927 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2928 sent along with the request as metadata. Normally, each value must be of type `str`,
2929 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2930 be of type `bytes`.
2932 Returns:
2933 ~.policy_pb2.Policy:
2934 An Identity and Access Management (IAM) policy, which
2935 specifies access controls for Google Cloud resources.
2937 A ``Policy`` is a collection of ``bindings``. A
2938 ``binding`` binds one or more ``members``, or
2939 principals, to a single ``role``. Principals can be user
2940 accounts, service accounts, Google groups, and domains
2941 (such as G Suite). A ``role`` is a named list of
2942 permissions; each ``role`` can be an IAM predefined role
2943 or a user-created custom role.
2945 For some types of Google Cloud resources, a ``binding``
2946 can also specify a ``condition``, which is a logical
2947 expression that allows access to a resource only if the
2948 expression evaluates to ``true``. A condition can add
2949 constraints based on attributes of the request, the
2950 resource, or both. To learn which resources support
2951 conditions in their IAM policies, see the `IAM
2952 documentation <https://cloud.google.com/iam/help/conditions/resource-policies>`__.
2954 **JSON example:**
2956 ::
2958 {
2959 "bindings": [
2960 {
2961 "role": "roles/resourcemanager.organizationAdmin",
2962 "members": [
2963 "user:mike@example.com",
2964 "group:admins@example.com",
2965 "domain:google.com",
2966 "serviceAccount:my-project-id@appspot.gserviceaccount.com"
2967 ]
2968 },
2969 {
2970 "role": "roles/resourcemanager.organizationViewer",
2971 "members": [
2972 "user:eve@example.com"
2973 ],
2974 "condition": {
2975 "title": "expirable access",
2976 "description": "Does not grant access after Sep 2020",
2977 "expression": "request.time <
2978 timestamp('2020-10-01T00:00:00.000Z')",
2979 }
2980 }
2981 ],
2982 "etag": "BwWWja0YfJA=",
2983 "version": 3
2984 }
2986 **YAML example:**
2988 ::
2990 bindings:
2991 - members:
2992 - user:mike@example.com
2993 - group:admins@example.com
2994 - domain:google.com
2995 - serviceAccount:my-project-id@appspot.gserviceaccount.com
2996 role: roles/resourcemanager.organizationAdmin
2997 - members:
2998 - user:eve@example.com
2999 role: roles/resourcemanager.organizationViewer
3000 condition:
3001 title: expirable access
3002 description: Does not grant access after Sep 2020
3003 expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
3004 etag: BwWWja0YfJA=
3005 version: 3
3007 For a description of IAM and its features, see the `IAM
3008 documentation <https://cloud.google.com/iam/docs/>`__.
3010 """
3012 http_options = _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy._get_http_options()
3014 request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
3015 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy._get_transcoded_request(
3016 http_options, request
3017 )
3019 body = _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy._get_request_body_json(
3020 transcoded_request
3021 )
3023 # Jsonify the query params
3024 query_params = _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy._get_query_params_json(
3025 transcoded_request
3026 )
3028 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3029 logging.DEBUG
3030 ): # pragma: NO COVER
3031 request_url = "{host}{uri}".format(
3032 host=self._host, uri=transcoded_request["uri"]
3033 )
3034 method = transcoded_request["method"]
3035 try:
3036 request_payload = json_format.MessageToJson(request)
3037 except:
3038 request_payload = None
3039 http_request = {
3040 "payload": request_payload,
3041 "requestMethod": method,
3042 "requestUrl": request_url,
3043 "headers": dict(metadata),
3044 }
3045 _LOGGER.debug(
3046 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.SetIamPolicy",
3047 extra={
3048 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3049 "rpcName": "SetIamPolicy",
3050 "httpRequest": http_request,
3051 "metadata": http_request["headers"],
3052 },
3053 )
3055 # Send the request
3056 response = SecretManagerServiceRestTransport._SetIamPolicy._get_response(
3057 self._host,
3058 metadata,
3059 query_params,
3060 self._session,
3061 timeout,
3062 transcoded_request,
3063 body,
3064 )
3066 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3067 # subclass.
3068 if response.status_code >= 400:
3069 raise core_exceptions.from_http_response(response)
3071 # Return the response
3072 resp = policy_pb2.Policy()
3073 pb_resp = resp
3075 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
3077 resp = self._interceptor.post_set_iam_policy(resp)
3078 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
3079 resp, _ = self._interceptor.post_set_iam_policy_with_metadata(
3080 resp, response_metadata
3081 )
3082 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3083 logging.DEBUG
3084 ): # pragma: NO COVER
3085 try:
3086 response_payload = json_format.MessageToJson(resp)
3087 except:
3088 response_payload = None
3089 http_response = {
3090 "payload": response_payload,
3091 "headers": dict(response.headers),
3092 "status": response.status_code,
3093 }
3094 _LOGGER.debug(
3095 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.set_iam_policy",
3096 extra={
3097 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3098 "rpcName": "SetIamPolicy",
3099 "metadata": http_response["headers"],
3100 "httpResponse": http_response,
3101 },
3102 )
3103 return resp
3105 class _TestIamPermissions(
3106 _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions,
3107 SecretManagerServiceRestStub,
3108 ):
3109 def __hash__(self):
3110 return hash("SecretManagerServiceRestTransport.TestIamPermissions")
3112 @staticmethod
3113 def _get_response(
3114 host,
3115 metadata,
3116 query_params,
3117 session,
3118 timeout,
3119 transcoded_request,
3120 body=None,
3121 ):
3122 uri = transcoded_request["uri"]
3123 method = transcoded_request["method"]
3124 headers = dict(metadata)
3125 headers["Content-Type"] = "application/json"
3126 response = getattr(session, method)(
3127 "{host}{uri}".format(host=host, uri=uri),
3128 timeout=timeout,
3129 headers=headers,
3130 params=rest_helpers.flatten_query_params(query_params, strict=True),
3131 data=body,
3132 )
3133 return response
3135 def __call__(
3136 self,
3137 request: iam_policy_pb2.TestIamPermissionsRequest,
3138 *,
3139 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3140 timeout: Optional[float] = None,
3141 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
3142 ) -> iam_policy_pb2.TestIamPermissionsResponse:
3143 r"""Call the test iam permissions method over HTTP.
3145 Args:
3146 request (~.iam_policy_pb2.TestIamPermissionsRequest):
3147 The request object. Request message for ``TestIamPermissions`` method.
3148 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3149 should be retried.
3150 timeout (float): The timeout for this request.
3151 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
3152 sent along with the request as metadata. Normally, each value must be of type `str`,
3153 but for metadata keys ending with the suffix `-bin`, the corresponding values must
3154 be of type `bytes`.
3156 Returns:
3157 ~.iam_policy_pb2.TestIamPermissionsResponse:
3158 Response message for ``TestIamPermissions`` method.
3159 """
3161 http_options = _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions._get_http_options()
3163 request, metadata = self._interceptor.pre_test_iam_permissions(
3164 request, metadata
3165 )
3166 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions._get_transcoded_request(
3167 http_options, request
3168 )
3170 body = _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions._get_request_body_json(
3171 transcoded_request
3172 )
3174 # Jsonify the query params
3175 query_params = _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions._get_query_params_json(
3176 transcoded_request
3177 )
3179 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3180 logging.DEBUG
3181 ): # pragma: NO COVER
3182 request_url = "{host}{uri}".format(
3183 host=self._host, uri=transcoded_request["uri"]
3184 )
3185 method = transcoded_request["method"]
3186 try:
3187 request_payload = json_format.MessageToJson(request)
3188 except:
3189 request_payload = None
3190 http_request = {
3191 "payload": request_payload,
3192 "requestMethod": method,
3193 "requestUrl": request_url,
3194 "headers": dict(metadata),
3195 }
3196 _LOGGER.debug(
3197 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.TestIamPermissions",
3198 extra={
3199 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3200 "rpcName": "TestIamPermissions",
3201 "httpRequest": http_request,
3202 "metadata": http_request["headers"],
3203 },
3204 )
3206 # Send the request
3207 response = (
3208 SecretManagerServiceRestTransport._TestIamPermissions._get_response(
3209 self._host,
3210 metadata,
3211 query_params,
3212 self._session,
3213 timeout,
3214 transcoded_request,
3215 body,
3216 )
3217 )
3219 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3220 # subclass.
3221 if response.status_code >= 400:
3222 raise core_exceptions.from_http_response(response)
3224 # Return the response
3225 resp = iam_policy_pb2.TestIamPermissionsResponse()
3226 pb_resp = resp
3228 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
3230 resp = self._interceptor.post_test_iam_permissions(resp)
3231 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
3232 resp, _ = self._interceptor.post_test_iam_permissions_with_metadata(
3233 resp, response_metadata
3234 )
3235 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3236 logging.DEBUG
3237 ): # pragma: NO COVER
3238 try:
3239 response_payload = json_format.MessageToJson(resp)
3240 except:
3241 response_payload = None
3242 http_response = {
3243 "payload": response_payload,
3244 "headers": dict(response.headers),
3245 "status": response.status_code,
3246 }
3247 _LOGGER.debug(
3248 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.test_iam_permissions",
3249 extra={
3250 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3251 "rpcName": "TestIamPermissions",
3252 "metadata": http_response["headers"],
3253 "httpResponse": http_response,
3254 },
3255 )
3256 return resp
3258 class _UpdateSecret(
3259 _BaseSecretManagerServiceRestTransport._BaseUpdateSecret,
3260 SecretManagerServiceRestStub,
3261 ):
3262 def __hash__(self):
3263 return hash("SecretManagerServiceRestTransport.UpdateSecret")
3265 @staticmethod
3266 def _get_response(
3267 host,
3268 metadata,
3269 query_params,
3270 session,
3271 timeout,
3272 transcoded_request,
3273 body=None,
3274 ):
3275 uri = transcoded_request["uri"]
3276 method = transcoded_request["method"]
3277 headers = dict(metadata)
3278 headers["Content-Type"] = "application/json"
3279 response = getattr(session, method)(
3280 "{host}{uri}".format(host=host, uri=uri),
3281 timeout=timeout,
3282 headers=headers,
3283 params=rest_helpers.flatten_query_params(query_params, strict=True),
3284 data=body,
3285 )
3286 return response
3288 def __call__(
3289 self,
3290 request: service.UpdateSecretRequest,
3291 *,
3292 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3293 timeout: Optional[float] = None,
3294 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
3295 ) -> resources.Secret:
3296 r"""Call the update secret method over HTTP.
3298 Args:
3299 request (~.service.UpdateSecretRequest):
3300 The request object. Request message for
3301 [SecretManagerService.UpdateSecret][google.cloud.secrets.v1beta1.SecretManagerService.UpdateSecret].
3302 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3303 should be retried.
3304 timeout (float): The timeout for this request.
3305 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
3306 sent along with the request as metadata. Normally, each value must be of type `str`,
3307 but for metadata keys ending with the suffix `-bin`, the corresponding values must
3308 be of type `bytes`.
3310 Returns:
3311 ~.resources.Secret:
3312 A [Secret][google.cloud.secrets.v1beta1.Secret] is a
3313 logical secret whose value and versions can be accessed.
3315 A [Secret][google.cloud.secrets.v1beta1.Secret] is made
3316 up of zero or more
3317 [SecretVersions][google.cloud.secrets.v1beta1.SecretVersion]
3318 that represent the secret data.
3320 """
3322 http_options = _BaseSecretManagerServiceRestTransport._BaseUpdateSecret._get_http_options()
3324 request, metadata = self._interceptor.pre_update_secret(request, metadata)
3325 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseUpdateSecret._get_transcoded_request(
3326 http_options, request
3327 )
3329 body = _BaseSecretManagerServiceRestTransport._BaseUpdateSecret._get_request_body_json(
3330 transcoded_request
3331 )
3333 # Jsonify the query params
3334 query_params = _BaseSecretManagerServiceRestTransport._BaseUpdateSecret._get_query_params_json(
3335 transcoded_request
3336 )
3338 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3339 logging.DEBUG
3340 ): # pragma: NO COVER
3341 request_url = "{host}{uri}".format(
3342 host=self._host, uri=transcoded_request["uri"]
3343 )
3344 method = transcoded_request["method"]
3345 try:
3346 request_payload = type(request).to_json(request)
3347 except:
3348 request_payload = None
3349 http_request = {
3350 "payload": request_payload,
3351 "requestMethod": method,
3352 "requestUrl": request_url,
3353 "headers": dict(metadata),
3354 }
3355 _LOGGER.debug(
3356 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.UpdateSecret",
3357 extra={
3358 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3359 "rpcName": "UpdateSecret",
3360 "httpRequest": http_request,
3361 "metadata": http_request["headers"],
3362 },
3363 )
3365 # Send the request
3366 response = SecretManagerServiceRestTransport._UpdateSecret._get_response(
3367 self._host,
3368 metadata,
3369 query_params,
3370 self._session,
3371 timeout,
3372 transcoded_request,
3373 body,
3374 )
3376 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3377 # subclass.
3378 if response.status_code >= 400:
3379 raise core_exceptions.from_http_response(response)
3381 # Return the response
3382 resp = resources.Secret()
3383 pb_resp = resources.Secret.pb(resp)
3385 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
3387 resp = self._interceptor.post_update_secret(resp)
3388 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
3389 resp, _ = self._interceptor.post_update_secret_with_metadata(
3390 resp, response_metadata
3391 )
3392 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3393 logging.DEBUG
3394 ): # pragma: NO COVER
3395 try:
3396 response_payload = resources.Secret.to_json(response)
3397 except:
3398 response_payload = None
3399 http_response = {
3400 "payload": response_payload,
3401 "headers": dict(response.headers),
3402 "status": response.status_code,
3403 }
3404 _LOGGER.debug(
3405 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.update_secret",
3406 extra={
3407 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3408 "rpcName": "UpdateSecret",
3409 "metadata": http_response["headers"],
3410 "httpResponse": http_response,
3411 },
3412 )
3413 return resp
3415 @property
3416 def access_secret_version(
3417 self,
3418 ) -> Callable[
3419 [service.AccessSecretVersionRequest], service.AccessSecretVersionResponse
3420 ]:
3421 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3422 # In C++ this would require a dynamic_cast
3423 return self._AccessSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3425 @property
3426 def add_secret_version(
3427 self,
3428 ) -> Callable[[service.AddSecretVersionRequest], resources.SecretVersion]:
3429 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3430 # In C++ this would require a dynamic_cast
3431 return self._AddSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3433 @property
3434 def create_secret(
3435 self,
3436 ) -> Callable[[service.CreateSecretRequest], resources.Secret]:
3437 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3438 # In C++ this would require a dynamic_cast
3439 return self._CreateSecret(self._session, self._host, self._interceptor) # type: ignore
3441 @property
3442 def delete_secret(self) -> Callable[[service.DeleteSecretRequest], empty_pb2.Empty]:
3443 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3444 # In C++ this would require a dynamic_cast
3445 return self._DeleteSecret(self._session, self._host, self._interceptor) # type: ignore
3447 @property
3448 def destroy_secret_version(
3449 self,
3450 ) -> Callable[[service.DestroySecretVersionRequest], resources.SecretVersion]:
3451 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3452 # In C++ this would require a dynamic_cast
3453 return self._DestroySecretVersion(self._session, self._host, self._interceptor) # type: ignore
3455 @property
3456 def disable_secret_version(
3457 self,
3458 ) -> Callable[[service.DisableSecretVersionRequest], resources.SecretVersion]:
3459 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3460 # In C++ this would require a dynamic_cast
3461 return self._DisableSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3463 @property
3464 def enable_secret_version(
3465 self,
3466 ) -> Callable[[service.EnableSecretVersionRequest], resources.SecretVersion]:
3467 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3468 # In C++ this would require a dynamic_cast
3469 return self._EnableSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3471 @property
3472 def get_iam_policy(
3473 self,
3474 ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
3475 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3476 # In C++ this would require a dynamic_cast
3477 return self._GetIamPolicy(self._session, self._host, self._interceptor) # type: ignore
3479 @property
3480 def get_secret(self) -> Callable[[service.GetSecretRequest], resources.Secret]:
3481 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3482 # In C++ this would require a dynamic_cast
3483 return self._GetSecret(self._session, self._host, self._interceptor) # type: ignore
3485 @property
3486 def get_secret_version(
3487 self,
3488 ) -> Callable[[service.GetSecretVersionRequest], resources.SecretVersion]:
3489 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3490 # In C++ this would require a dynamic_cast
3491 return self._GetSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3493 @property
3494 def list_secrets(
3495 self,
3496 ) -> Callable[[service.ListSecretsRequest], service.ListSecretsResponse]:
3497 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3498 # In C++ this would require a dynamic_cast
3499 return self._ListSecrets(self._session, self._host, self._interceptor) # type: ignore
3501 @property
3502 def list_secret_versions(
3503 self,
3504 ) -> Callable[
3505 [service.ListSecretVersionsRequest], service.ListSecretVersionsResponse
3506 ]:
3507 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3508 # In C++ this would require a dynamic_cast
3509 return self._ListSecretVersions(self._session, self._host, self._interceptor) # type: ignore
3511 @property
3512 def set_iam_policy(
3513 self,
3514 ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
3515 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3516 # In C++ this would require a dynamic_cast
3517 return self._SetIamPolicy(self._session, self._host, self._interceptor) # type: ignore
3519 @property
3520 def test_iam_permissions(
3521 self,
3522 ) -> Callable[
3523 [iam_policy_pb2.TestIamPermissionsRequest],
3524 iam_policy_pb2.TestIamPermissionsResponse,
3525 ]:
3526 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3527 # In C++ this would require a dynamic_cast
3528 return self._TestIamPermissions(self._session, self._host, self._interceptor) # type: ignore
3530 @property
3531 def update_secret(
3532 self,
3533 ) -> Callable[[service.UpdateSecretRequest], resources.Secret]:
3534 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3535 # In C++ this would require a dynamic_cast
3536 return self._UpdateSecret(self._session, self._host, self._interceptor) # type: ignore
3538 @property
3539 def get_location(self):
3540 return self._GetLocation(self._session, self._host, self._interceptor) # type: ignore
3542 class _GetLocation(
3543 _BaseSecretManagerServiceRestTransport._BaseGetLocation,
3544 SecretManagerServiceRestStub,
3545 ):
3546 def __hash__(self):
3547 return hash("SecretManagerServiceRestTransport.GetLocation")
3549 @staticmethod
3550 def _get_response(
3551 host,
3552 metadata,
3553 query_params,
3554 session,
3555 timeout,
3556 transcoded_request,
3557 body=None,
3558 ):
3559 uri = transcoded_request["uri"]
3560 method = transcoded_request["method"]
3561 headers = dict(metadata)
3562 headers["Content-Type"] = "application/json"
3563 response = getattr(session, method)(
3564 "{host}{uri}".format(host=host, uri=uri),
3565 timeout=timeout,
3566 headers=headers,
3567 params=rest_helpers.flatten_query_params(query_params, strict=True),
3568 )
3569 return response
3571 def __call__(
3572 self,
3573 request: locations_pb2.GetLocationRequest,
3574 *,
3575 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3576 timeout: Optional[float] = None,
3577 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
3578 ) -> locations_pb2.Location:
3579 r"""Call the get location method over HTTP.
3581 Args:
3582 request (locations_pb2.GetLocationRequest):
3583 The request object for GetLocation method.
3584 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3585 should be retried.
3586 timeout (float): The timeout for this request.
3587 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
3588 sent along with the request as metadata. Normally, each value must be of type `str`,
3589 but for metadata keys ending with the suffix `-bin`, the corresponding values must
3590 be of type `bytes`.
3592 Returns:
3593 locations_pb2.Location: Response from GetLocation method.
3594 """
3596 http_options = _BaseSecretManagerServiceRestTransport._BaseGetLocation._get_http_options()
3598 request, metadata = self._interceptor.pre_get_location(request, metadata)
3599 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseGetLocation._get_transcoded_request(
3600 http_options, request
3601 )
3603 # Jsonify the query params
3604 query_params = _BaseSecretManagerServiceRestTransport._BaseGetLocation._get_query_params_json(
3605 transcoded_request
3606 )
3608 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3609 logging.DEBUG
3610 ): # pragma: NO COVER
3611 request_url = "{host}{uri}".format(
3612 host=self._host, uri=transcoded_request["uri"]
3613 )
3614 method = transcoded_request["method"]
3615 try:
3616 request_payload = json_format.MessageToJson(request)
3617 except:
3618 request_payload = None
3619 http_request = {
3620 "payload": request_payload,
3621 "requestMethod": method,
3622 "requestUrl": request_url,
3623 "headers": dict(metadata),
3624 }
3625 _LOGGER.debug(
3626 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.GetLocation",
3627 extra={
3628 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3629 "rpcName": "GetLocation",
3630 "httpRequest": http_request,
3631 "metadata": http_request["headers"],
3632 },
3633 )
3635 # Send the request
3636 response = SecretManagerServiceRestTransport._GetLocation._get_response(
3637 self._host,
3638 metadata,
3639 query_params,
3640 self._session,
3641 timeout,
3642 transcoded_request,
3643 )
3645 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3646 # subclass.
3647 if response.status_code >= 400:
3648 raise core_exceptions.from_http_response(response)
3650 content = response.content.decode("utf-8")
3651 resp = locations_pb2.Location()
3652 resp = json_format.Parse(content, resp)
3653 resp = self._interceptor.post_get_location(resp)
3654 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3655 logging.DEBUG
3656 ): # pragma: NO COVER
3657 try:
3658 response_payload = json_format.MessageToJson(resp)
3659 except:
3660 response_payload = None
3661 http_response = {
3662 "payload": response_payload,
3663 "headers": dict(response.headers),
3664 "status": response.status_code,
3665 }
3666 _LOGGER.debug(
3667 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceAsyncClient.GetLocation",
3668 extra={
3669 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3670 "rpcName": "GetLocation",
3671 "httpResponse": http_response,
3672 "metadata": http_response["headers"],
3673 },
3674 )
3675 return resp
3677 @property
3678 def list_locations(self):
3679 return self._ListLocations(self._session, self._host, self._interceptor) # type: ignore
3681 class _ListLocations(
3682 _BaseSecretManagerServiceRestTransport._BaseListLocations,
3683 SecretManagerServiceRestStub,
3684 ):
3685 def __hash__(self):
3686 return hash("SecretManagerServiceRestTransport.ListLocations")
3688 @staticmethod
3689 def _get_response(
3690 host,
3691 metadata,
3692 query_params,
3693 session,
3694 timeout,
3695 transcoded_request,
3696 body=None,
3697 ):
3698 uri = transcoded_request["uri"]
3699 method = transcoded_request["method"]
3700 headers = dict(metadata)
3701 headers["Content-Type"] = "application/json"
3702 response = getattr(session, method)(
3703 "{host}{uri}".format(host=host, uri=uri),
3704 timeout=timeout,
3705 headers=headers,
3706 params=rest_helpers.flatten_query_params(query_params, strict=True),
3707 )
3708 return response
3710 def __call__(
3711 self,
3712 request: locations_pb2.ListLocationsRequest,
3713 *,
3714 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3715 timeout: Optional[float] = None,
3716 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
3717 ) -> locations_pb2.ListLocationsResponse:
3718 r"""Call the list locations method over HTTP.
3720 Args:
3721 request (locations_pb2.ListLocationsRequest):
3722 The request object for ListLocations method.
3723 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3724 should be retried.
3725 timeout (float): The timeout for this request.
3726 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
3727 sent along with the request as metadata. Normally, each value must be of type `str`,
3728 but for metadata keys ending with the suffix `-bin`, the corresponding values must
3729 be of type `bytes`.
3731 Returns:
3732 locations_pb2.ListLocationsResponse: Response from ListLocations method.
3733 """
3735 http_options = _BaseSecretManagerServiceRestTransport._BaseListLocations._get_http_options()
3737 request, metadata = self._interceptor.pre_list_locations(request, metadata)
3738 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseListLocations._get_transcoded_request(
3739 http_options, request
3740 )
3742 # Jsonify the query params
3743 query_params = _BaseSecretManagerServiceRestTransport._BaseListLocations._get_query_params_json(
3744 transcoded_request
3745 )
3747 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3748 logging.DEBUG
3749 ): # pragma: NO COVER
3750 request_url = "{host}{uri}".format(
3751 host=self._host, uri=transcoded_request["uri"]
3752 )
3753 method = transcoded_request["method"]
3754 try:
3755 request_payload = json_format.MessageToJson(request)
3756 except:
3757 request_payload = None
3758 http_request = {
3759 "payload": request_payload,
3760 "requestMethod": method,
3761 "requestUrl": request_url,
3762 "headers": dict(metadata),
3763 }
3764 _LOGGER.debug(
3765 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.ListLocations",
3766 extra={
3767 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3768 "rpcName": "ListLocations",
3769 "httpRequest": http_request,
3770 "metadata": http_request["headers"],
3771 },
3772 )
3774 # Send the request
3775 response = SecretManagerServiceRestTransport._ListLocations._get_response(
3776 self._host,
3777 metadata,
3778 query_params,
3779 self._session,
3780 timeout,
3781 transcoded_request,
3782 )
3784 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3785 # subclass.
3786 if response.status_code >= 400:
3787 raise core_exceptions.from_http_response(response)
3789 content = response.content.decode("utf-8")
3790 resp = locations_pb2.ListLocationsResponse()
3791 resp = json_format.Parse(content, resp)
3792 resp = self._interceptor.post_list_locations(resp)
3793 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3794 logging.DEBUG
3795 ): # pragma: NO COVER
3796 try:
3797 response_payload = json_format.MessageToJson(resp)
3798 except:
3799 response_payload = None
3800 http_response = {
3801 "payload": response_payload,
3802 "headers": dict(response.headers),
3803 "status": response.status_code,
3804 }
3805 _LOGGER.debug(
3806 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceAsyncClient.ListLocations",
3807 extra={
3808 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3809 "rpcName": "ListLocations",
3810 "httpResponse": http_response,
3811 "metadata": http_response["headers"],
3812 },
3813 )
3814 return resp
3816 @property
3817 def kind(self) -> str:
3818 return "rest"
3820 def close(self):
3821 self._session.close()
3824__all__ = ("SecretManagerServiceRestTransport",)