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)
60DEFAULT_CLIENT_INFO.protobuf_runtime_version = google.protobuf.__version__
63class SecretManagerServiceRestInterceptor:
64 """Interceptor for SecretManagerService.
66 Interceptors are used to manipulate requests, request metadata, and responses
67 in arbitrary ways.
68 Example use cases include:
69 * Logging
70 * Verifying requests according to service or custom semantics
71 * Stripping extraneous information from responses
73 These use cases and more can be enabled by injecting an
74 instance of a custom subclass when constructing the SecretManagerServiceRestTransport.
76 .. code-block:: python
77 class MyCustomSecretManagerServiceInterceptor(SecretManagerServiceRestInterceptor):
78 def pre_access_secret_version(self, request, metadata):
79 logging.log(f"Received request: {request}")
80 return request, metadata
82 def post_access_secret_version(self, response):
83 logging.log(f"Received response: {response}")
84 return response
86 def pre_add_secret_version(self, request, metadata):
87 logging.log(f"Received request: {request}")
88 return request, metadata
90 def post_add_secret_version(self, response):
91 logging.log(f"Received response: {response}")
92 return response
94 def pre_create_secret(self, request, metadata):
95 logging.log(f"Received request: {request}")
96 return request, metadata
98 def post_create_secret(self, response):
99 logging.log(f"Received response: {response}")
100 return response
102 def pre_delete_secret(self, request, metadata):
103 logging.log(f"Received request: {request}")
104 return request, metadata
106 def pre_destroy_secret_version(self, request, metadata):
107 logging.log(f"Received request: {request}")
108 return request, metadata
110 def post_destroy_secret_version(self, response):
111 logging.log(f"Received response: {response}")
112 return response
114 def pre_disable_secret_version(self, request, metadata):
115 logging.log(f"Received request: {request}")
116 return request, metadata
118 def post_disable_secret_version(self, response):
119 logging.log(f"Received response: {response}")
120 return response
122 def pre_enable_secret_version(self, request, metadata):
123 logging.log(f"Received request: {request}")
124 return request, metadata
126 def post_enable_secret_version(self, response):
127 logging.log(f"Received response: {response}")
128 return response
130 def pre_get_iam_policy(self, request, metadata):
131 logging.log(f"Received request: {request}")
132 return request, metadata
134 def post_get_iam_policy(self, response):
135 logging.log(f"Received response: {response}")
136 return response
138 def pre_get_secret(self, request, metadata):
139 logging.log(f"Received request: {request}")
140 return request, metadata
142 def post_get_secret(self, response):
143 logging.log(f"Received response: {response}")
144 return response
146 def pre_get_secret_version(self, request, metadata):
147 logging.log(f"Received request: {request}")
148 return request, metadata
150 def post_get_secret_version(self, response):
151 logging.log(f"Received response: {response}")
152 return response
154 def pre_list_secrets(self, request, metadata):
155 logging.log(f"Received request: {request}")
156 return request, metadata
158 def post_list_secrets(self, response):
159 logging.log(f"Received response: {response}")
160 return response
162 def pre_list_secret_versions(self, request, metadata):
163 logging.log(f"Received request: {request}")
164 return request, metadata
166 def post_list_secret_versions(self, response):
167 logging.log(f"Received response: {response}")
168 return response
170 def pre_set_iam_policy(self, request, metadata):
171 logging.log(f"Received request: {request}")
172 return request, metadata
174 def post_set_iam_policy(self, response):
175 logging.log(f"Received response: {response}")
176 return response
178 def pre_test_iam_permissions(self, request, metadata):
179 logging.log(f"Received request: {request}")
180 return request, metadata
182 def post_test_iam_permissions(self, response):
183 logging.log(f"Received response: {response}")
184 return response
186 def pre_update_secret(self, request, metadata):
187 logging.log(f"Received request: {request}")
188 return request, metadata
190 def post_update_secret(self, response):
191 logging.log(f"Received response: {response}")
192 return response
194 transport = SecretManagerServiceRestTransport(interceptor=MyCustomSecretManagerServiceInterceptor())
195 client = SecretManagerServiceClient(transport=transport)
198 """
200 def pre_access_secret_version(
201 self,
202 request: service.AccessSecretVersionRequest,
203 metadata: Sequence[Tuple[str, Union[str, bytes]]],
204 ) -> Tuple[
205 service.AccessSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
206 ]:
207 """Pre-rpc interceptor for access_secret_version
209 Override in a subclass to manipulate the request or metadata
210 before they are sent to the SecretManagerService server.
211 """
212 return request, metadata
214 def post_access_secret_version(
215 self, response: service.AccessSecretVersionResponse
216 ) -> service.AccessSecretVersionResponse:
217 """Post-rpc interceptor for access_secret_version
219 DEPRECATED. Please use the `post_access_secret_version_with_metadata`
220 interceptor instead.
222 Override in a subclass to read or manipulate the response
223 after it is returned by the SecretManagerService server but before
224 it is returned to user code. This `post_access_secret_version` interceptor runs
225 before the `post_access_secret_version_with_metadata` interceptor.
226 """
227 return response
229 def post_access_secret_version_with_metadata(
230 self,
231 response: service.AccessSecretVersionResponse,
232 metadata: Sequence[Tuple[str, Union[str, bytes]]],
233 ) -> Tuple[
234 service.AccessSecretVersionResponse, Sequence[Tuple[str, Union[str, bytes]]]
235 ]:
236 """Post-rpc interceptor for access_secret_version
238 Override in a subclass to read or manipulate the response or metadata after it
239 is returned by the SecretManagerService server but before it is returned to user code.
241 We recommend only using this `post_access_secret_version_with_metadata`
242 interceptor in new development instead of the `post_access_secret_version` interceptor.
243 When both interceptors are used, this `post_access_secret_version_with_metadata` interceptor runs after the
244 `post_access_secret_version` interceptor. The (possibly modified) response returned by
245 `post_access_secret_version` will be passed to
246 `post_access_secret_version_with_metadata`.
247 """
248 return response, metadata
250 def pre_add_secret_version(
251 self,
252 request: service.AddSecretVersionRequest,
253 metadata: Sequence[Tuple[str, Union[str, bytes]]],
254 ) -> Tuple[
255 service.AddSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
256 ]:
257 """Pre-rpc interceptor for add_secret_version
259 Override in a subclass to manipulate the request or metadata
260 before they are sent to the SecretManagerService server.
261 """
262 return request, metadata
264 def post_add_secret_version(
265 self, response: resources.SecretVersion
266 ) -> resources.SecretVersion:
267 """Post-rpc interceptor for add_secret_version
269 DEPRECATED. Please use the `post_add_secret_version_with_metadata`
270 interceptor instead.
272 Override in a subclass to read or manipulate the response
273 after it is returned by the SecretManagerService server but before
274 it is returned to user code. This `post_add_secret_version` interceptor runs
275 before the `post_add_secret_version_with_metadata` interceptor.
276 """
277 return response
279 def post_add_secret_version_with_metadata(
280 self,
281 response: resources.SecretVersion,
282 metadata: Sequence[Tuple[str, Union[str, bytes]]],
283 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
284 """Post-rpc interceptor for add_secret_version
286 Override in a subclass to read or manipulate the response or metadata after it
287 is returned by the SecretManagerService server but before it is returned to user code.
289 We recommend only using this `post_add_secret_version_with_metadata`
290 interceptor in new development instead of the `post_add_secret_version` interceptor.
291 When both interceptors are used, this `post_add_secret_version_with_metadata` interceptor runs after the
292 `post_add_secret_version` interceptor. The (possibly modified) response returned by
293 `post_add_secret_version` will be passed to
294 `post_add_secret_version_with_metadata`.
295 """
296 return response, metadata
298 def pre_create_secret(
299 self,
300 request: service.CreateSecretRequest,
301 metadata: Sequence[Tuple[str, Union[str, bytes]]],
302 ) -> Tuple[service.CreateSecretRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
303 """Pre-rpc interceptor for create_secret
305 Override in a subclass to manipulate the request or metadata
306 before they are sent to the SecretManagerService server.
307 """
308 return request, metadata
310 def post_create_secret(self, response: resources.Secret) -> resources.Secret:
311 """Post-rpc interceptor for create_secret
313 DEPRECATED. Please use the `post_create_secret_with_metadata`
314 interceptor instead.
316 Override in a subclass to read or manipulate the response
317 after it is returned by the SecretManagerService server but before
318 it is returned to user code. This `post_create_secret` interceptor runs
319 before the `post_create_secret_with_metadata` interceptor.
320 """
321 return response
323 def post_create_secret_with_metadata(
324 self,
325 response: resources.Secret,
326 metadata: Sequence[Tuple[str, Union[str, bytes]]],
327 ) -> Tuple[resources.Secret, Sequence[Tuple[str, Union[str, bytes]]]]:
328 """Post-rpc interceptor for create_secret
330 Override in a subclass to read or manipulate the response or metadata after it
331 is returned by the SecretManagerService server but before it is returned to user code.
333 We recommend only using this `post_create_secret_with_metadata`
334 interceptor in new development instead of the `post_create_secret` interceptor.
335 When both interceptors are used, this `post_create_secret_with_metadata` interceptor runs after the
336 `post_create_secret` interceptor. The (possibly modified) response returned by
337 `post_create_secret` will be passed to
338 `post_create_secret_with_metadata`.
339 """
340 return response, metadata
342 def pre_delete_secret(
343 self,
344 request: service.DeleteSecretRequest,
345 metadata: Sequence[Tuple[str, Union[str, bytes]]],
346 ) -> Tuple[service.DeleteSecretRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
347 """Pre-rpc interceptor for delete_secret
349 Override in a subclass to manipulate the request or metadata
350 before they are sent to the SecretManagerService server.
351 """
352 return request, metadata
354 def pre_destroy_secret_version(
355 self,
356 request: service.DestroySecretVersionRequest,
357 metadata: Sequence[Tuple[str, Union[str, bytes]]],
358 ) -> Tuple[
359 service.DestroySecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
360 ]:
361 """Pre-rpc interceptor for destroy_secret_version
363 Override in a subclass to manipulate the request or metadata
364 before they are sent to the SecretManagerService server.
365 """
366 return request, metadata
368 def post_destroy_secret_version(
369 self, response: resources.SecretVersion
370 ) -> resources.SecretVersion:
371 """Post-rpc interceptor for destroy_secret_version
373 DEPRECATED. Please use the `post_destroy_secret_version_with_metadata`
374 interceptor instead.
376 Override in a subclass to read or manipulate the response
377 after it is returned by the SecretManagerService server but before
378 it is returned to user code. This `post_destroy_secret_version` interceptor runs
379 before the `post_destroy_secret_version_with_metadata` interceptor.
380 """
381 return response
383 def post_destroy_secret_version_with_metadata(
384 self,
385 response: resources.SecretVersion,
386 metadata: Sequence[Tuple[str, Union[str, bytes]]],
387 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
388 """Post-rpc interceptor for destroy_secret_version
390 Override in a subclass to read or manipulate the response or metadata after it
391 is returned by the SecretManagerService server but before it is returned to user code.
393 We recommend only using this `post_destroy_secret_version_with_metadata`
394 interceptor in new development instead of the `post_destroy_secret_version` interceptor.
395 When both interceptors are used, this `post_destroy_secret_version_with_metadata` interceptor runs after the
396 `post_destroy_secret_version` interceptor. The (possibly modified) response returned by
397 `post_destroy_secret_version` will be passed to
398 `post_destroy_secret_version_with_metadata`.
399 """
400 return response, metadata
402 def pre_disable_secret_version(
403 self,
404 request: service.DisableSecretVersionRequest,
405 metadata: Sequence[Tuple[str, Union[str, bytes]]],
406 ) -> Tuple[
407 service.DisableSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
408 ]:
409 """Pre-rpc interceptor for disable_secret_version
411 Override in a subclass to manipulate the request or metadata
412 before they are sent to the SecretManagerService server.
413 """
414 return request, metadata
416 def post_disable_secret_version(
417 self, response: resources.SecretVersion
418 ) -> resources.SecretVersion:
419 """Post-rpc interceptor for disable_secret_version
421 DEPRECATED. Please use the `post_disable_secret_version_with_metadata`
422 interceptor instead.
424 Override in a subclass to read or manipulate the response
425 after it is returned by the SecretManagerService server but before
426 it is returned to user code. This `post_disable_secret_version` interceptor runs
427 before the `post_disable_secret_version_with_metadata` interceptor.
428 """
429 return response
431 def post_disable_secret_version_with_metadata(
432 self,
433 response: resources.SecretVersion,
434 metadata: Sequence[Tuple[str, Union[str, bytes]]],
435 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
436 """Post-rpc interceptor for disable_secret_version
438 Override in a subclass to read or manipulate the response or metadata after it
439 is returned by the SecretManagerService server but before it is returned to user code.
441 We recommend only using this `post_disable_secret_version_with_metadata`
442 interceptor in new development instead of the `post_disable_secret_version` interceptor.
443 When both interceptors are used, this `post_disable_secret_version_with_metadata` interceptor runs after the
444 `post_disable_secret_version` interceptor. The (possibly modified) response returned by
445 `post_disable_secret_version` will be passed to
446 `post_disable_secret_version_with_metadata`.
447 """
448 return response, metadata
450 def pre_enable_secret_version(
451 self,
452 request: service.EnableSecretVersionRequest,
453 metadata: Sequence[Tuple[str, Union[str, bytes]]],
454 ) -> Tuple[
455 service.EnableSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
456 ]:
457 """Pre-rpc interceptor for enable_secret_version
459 Override in a subclass to manipulate the request or metadata
460 before they are sent to the SecretManagerService server.
461 """
462 return request, metadata
464 def post_enable_secret_version(
465 self, response: resources.SecretVersion
466 ) -> resources.SecretVersion:
467 """Post-rpc interceptor for enable_secret_version
469 DEPRECATED. Please use the `post_enable_secret_version_with_metadata`
470 interceptor instead.
472 Override in a subclass to read or manipulate the response
473 after it is returned by the SecretManagerService server but before
474 it is returned to user code. This `post_enable_secret_version` interceptor runs
475 before the `post_enable_secret_version_with_metadata` interceptor.
476 """
477 return response
479 def post_enable_secret_version_with_metadata(
480 self,
481 response: resources.SecretVersion,
482 metadata: Sequence[Tuple[str, Union[str, bytes]]],
483 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
484 """Post-rpc interceptor for enable_secret_version
486 Override in a subclass to read or manipulate the response or metadata after it
487 is returned by the SecretManagerService server but before it is returned to user code.
489 We recommend only using this `post_enable_secret_version_with_metadata`
490 interceptor in new development instead of the `post_enable_secret_version` interceptor.
491 When both interceptors are used, this `post_enable_secret_version_with_metadata` interceptor runs after the
492 `post_enable_secret_version` interceptor. The (possibly modified) response returned by
493 `post_enable_secret_version` will be passed to
494 `post_enable_secret_version_with_metadata`.
495 """
496 return response, metadata
498 def pre_get_iam_policy(
499 self,
500 request: iam_policy_pb2.GetIamPolicyRequest,
501 metadata: Sequence[Tuple[str, Union[str, bytes]]],
502 ) -> Tuple[
503 iam_policy_pb2.GetIamPolicyRequest, Sequence[Tuple[str, Union[str, bytes]]]
504 ]:
505 """Pre-rpc interceptor for get_iam_policy
507 Override in a subclass to manipulate the request or metadata
508 before they are sent to the SecretManagerService server.
509 """
510 return request, metadata
512 def post_get_iam_policy(self, response: policy_pb2.Policy) -> policy_pb2.Policy:
513 """Post-rpc interceptor for get_iam_policy
515 DEPRECATED. Please use the `post_get_iam_policy_with_metadata`
516 interceptor instead.
518 Override in a subclass to read or manipulate the response
519 after it is returned by the SecretManagerService server but before
520 it is returned to user code. This `post_get_iam_policy` interceptor runs
521 before the `post_get_iam_policy_with_metadata` interceptor.
522 """
523 return response
525 def post_get_iam_policy_with_metadata(
526 self,
527 response: policy_pb2.Policy,
528 metadata: Sequence[Tuple[str, Union[str, bytes]]],
529 ) -> Tuple[policy_pb2.Policy, Sequence[Tuple[str, Union[str, bytes]]]]:
530 """Post-rpc interceptor for get_iam_policy
532 Override in a subclass to read or manipulate the response or metadata after it
533 is returned by the SecretManagerService server but before it is returned to user code.
535 We recommend only using this `post_get_iam_policy_with_metadata`
536 interceptor in new development instead of the `post_get_iam_policy` interceptor.
537 When both interceptors are used, this `post_get_iam_policy_with_metadata` interceptor runs after the
538 `post_get_iam_policy` interceptor. The (possibly modified) response returned by
539 `post_get_iam_policy` will be passed to
540 `post_get_iam_policy_with_metadata`.
541 """
542 return response, metadata
544 def pre_get_secret(
545 self,
546 request: service.GetSecretRequest,
547 metadata: Sequence[Tuple[str, Union[str, bytes]]],
548 ) -> Tuple[service.GetSecretRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
549 """Pre-rpc interceptor for get_secret
551 Override in a subclass to manipulate the request or metadata
552 before they are sent to the SecretManagerService server.
553 """
554 return request, metadata
556 def post_get_secret(self, response: resources.Secret) -> resources.Secret:
557 """Post-rpc interceptor for get_secret
559 DEPRECATED. Please use the `post_get_secret_with_metadata`
560 interceptor instead.
562 Override in a subclass to read or manipulate the response
563 after it is returned by the SecretManagerService server but before
564 it is returned to user code. This `post_get_secret` interceptor runs
565 before the `post_get_secret_with_metadata` interceptor.
566 """
567 return response
569 def post_get_secret_with_metadata(
570 self,
571 response: resources.Secret,
572 metadata: Sequence[Tuple[str, Union[str, bytes]]],
573 ) -> Tuple[resources.Secret, Sequence[Tuple[str, Union[str, bytes]]]]:
574 """Post-rpc interceptor for get_secret
576 Override in a subclass to read or manipulate the response or metadata after it
577 is returned by the SecretManagerService server but before it is returned to user code.
579 We recommend only using this `post_get_secret_with_metadata`
580 interceptor in new development instead of the `post_get_secret` interceptor.
581 When both interceptors are used, this `post_get_secret_with_metadata` interceptor runs after the
582 `post_get_secret` interceptor. The (possibly modified) response returned by
583 `post_get_secret` will be passed to
584 `post_get_secret_with_metadata`.
585 """
586 return response, metadata
588 def pre_get_secret_version(
589 self,
590 request: service.GetSecretVersionRequest,
591 metadata: Sequence[Tuple[str, Union[str, bytes]]],
592 ) -> Tuple[
593 service.GetSecretVersionRequest, Sequence[Tuple[str, Union[str, bytes]]]
594 ]:
595 """Pre-rpc interceptor for get_secret_version
597 Override in a subclass to manipulate the request or metadata
598 before they are sent to the SecretManagerService server.
599 """
600 return request, metadata
602 def post_get_secret_version(
603 self, response: resources.SecretVersion
604 ) -> resources.SecretVersion:
605 """Post-rpc interceptor for get_secret_version
607 DEPRECATED. Please use the `post_get_secret_version_with_metadata`
608 interceptor instead.
610 Override in a subclass to read or manipulate the response
611 after it is returned by the SecretManagerService server but before
612 it is returned to user code. This `post_get_secret_version` interceptor runs
613 before the `post_get_secret_version_with_metadata` interceptor.
614 """
615 return response
617 def post_get_secret_version_with_metadata(
618 self,
619 response: resources.SecretVersion,
620 metadata: Sequence[Tuple[str, Union[str, bytes]]],
621 ) -> Tuple[resources.SecretVersion, Sequence[Tuple[str, Union[str, bytes]]]]:
622 """Post-rpc interceptor for get_secret_version
624 Override in a subclass to read or manipulate the response or metadata after it
625 is returned by the SecretManagerService server but before it is returned to user code.
627 We recommend only using this `post_get_secret_version_with_metadata`
628 interceptor in new development instead of the `post_get_secret_version` interceptor.
629 When both interceptors are used, this `post_get_secret_version_with_metadata` interceptor runs after the
630 `post_get_secret_version` interceptor. The (possibly modified) response returned by
631 `post_get_secret_version` will be passed to
632 `post_get_secret_version_with_metadata`.
633 """
634 return response, metadata
636 def pre_list_secrets(
637 self,
638 request: service.ListSecretsRequest,
639 metadata: Sequence[Tuple[str, Union[str, bytes]]],
640 ) -> Tuple[service.ListSecretsRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
641 """Pre-rpc interceptor for list_secrets
643 Override in a subclass to manipulate the request or metadata
644 before they are sent to the SecretManagerService server.
645 """
646 return request, metadata
648 def post_list_secrets(
649 self, response: service.ListSecretsResponse
650 ) -> service.ListSecretsResponse:
651 """Post-rpc interceptor for list_secrets
653 DEPRECATED. Please use the `post_list_secrets_with_metadata`
654 interceptor instead.
656 Override in a subclass to read or manipulate the response
657 after it is returned by the SecretManagerService server but before
658 it is returned to user code. This `post_list_secrets` interceptor runs
659 before the `post_list_secrets_with_metadata` interceptor.
660 """
661 return response
663 def post_list_secrets_with_metadata(
664 self,
665 response: service.ListSecretsResponse,
666 metadata: Sequence[Tuple[str, Union[str, bytes]]],
667 ) -> Tuple[service.ListSecretsResponse, Sequence[Tuple[str, Union[str, bytes]]]]:
668 """Post-rpc interceptor for list_secrets
670 Override in a subclass to read or manipulate the response or metadata after it
671 is returned by the SecretManagerService server but before it is returned to user code.
673 We recommend only using this `post_list_secrets_with_metadata`
674 interceptor in new development instead of the `post_list_secrets` interceptor.
675 When both interceptors are used, this `post_list_secrets_with_metadata` interceptor runs after the
676 `post_list_secrets` interceptor. The (possibly modified) response returned by
677 `post_list_secrets` will be passed to
678 `post_list_secrets_with_metadata`.
679 """
680 return response, metadata
682 def pre_list_secret_versions(
683 self,
684 request: service.ListSecretVersionsRequest,
685 metadata: Sequence[Tuple[str, Union[str, bytes]]],
686 ) -> Tuple[
687 service.ListSecretVersionsRequest, Sequence[Tuple[str, Union[str, bytes]]]
688 ]:
689 """Pre-rpc interceptor for list_secret_versions
691 Override in a subclass to manipulate the request or metadata
692 before they are sent to the SecretManagerService server.
693 """
694 return request, metadata
696 def post_list_secret_versions(
697 self, response: service.ListSecretVersionsResponse
698 ) -> service.ListSecretVersionsResponse:
699 """Post-rpc interceptor for list_secret_versions
701 DEPRECATED. Please use the `post_list_secret_versions_with_metadata`
702 interceptor instead.
704 Override in a subclass to read or manipulate the response
705 after it is returned by the SecretManagerService server but before
706 it is returned to user code. This `post_list_secret_versions` interceptor runs
707 before the `post_list_secret_versions_with_metadata` interceptor.
708 """
709 return response
711 def post_list_secret_versions_with_metadata(
712 self,
713 response: service.ListSecretVersionsResponse,
714 metadata: Sequence[Tuple[str, Union[str, bytes]]],
715 ) -> Tuple[
716 service.ListSecretVersionsResponse, Sequence[Tuple[str, Union[str, bytes]]]
717 ]:
718 """Post-rpc interceptor for list_secret_versions
720 Override in a subclass to read or manipulate the response or metadata after it
721 is returned by the SecretManagerService server but before it is returned to user code.
723 We recommend only using this `post_list_secret_versions_with_metadata`
724 interceptor in new development instead of the `post_list_secret_versions` interceptor.
725 When both interceptors are used, this `post_list_secret_versions_with_metadata` interceptor runs after the
726 `post_list_secret_versions` interceptor. The (possibly modified) response returned by
727 `post_list_secret_versions` will be passed to
728 `post_list_secret_versions_with_metadata`.
729 """
730 return response, metadata
732 def pre_set_iam_policy(
733 self,
734 request: iam_policy_pb2.SetIamPolicyRequest,
735 metadata: Sequence[Tuple[str, Union[str, bytes]]],
736 ) -> Tuple[
737 iam_policy_pb2.SetIamPolicyRequest, Sequence[Tuple[str, Union[str, bytes]]]
738 ]:
739 """Pre-rpc interceptor for set_iam_policy
741 Override in a subclass to manipulate the request or metadata
742 before they are sent to the SecretManagerService server.
743 """
744 return request, metadata
746 def post_set_iam_policy(self, response: policy_pb2.Policy) -> policy_pb2.Policy:
747 """Post-rpc interceptor for set_iam_policy
749 DEPRECATED. Please use the `post_set_iam_policy_with_metadata`
750 interceptor instead.
752 Override in a subclass to read or manipulate the response
753 after it is returned by the SecretManagerService server but before
754 it is returned to user code. This `post_set_iam_policy` interceptor runs
755 before the `post_set_iam_policy_with_metadata` interceptor.
756 """
757 return response
759 def post_set_iam_policy_with_metadata(
760 self,
761 response: policy_pb2.Policy,
762 metadata: Sequence[Tuple[str, Union[str, bytes]]],
763 ) -> Tuple[policy_pb2.Policy, Sequence[Tuple[str, Union[str, bytes]]]]:
764 """Post-rpc interceptor for set_iam_policy
766 Override in a subclass to read or manipulate the response or metadata after it
767 is returned by the SecretManagerService server but before it is returned to user code.
769 We recommend only using this `post_set_iam_policy_with_metadata`
770 interceptor in new development instead of the `post_set_iam_policy` interceptor.
771 When both interceptors are used, this `post_set_iam_policy_with_metadata` interceptor runs after the
772 `post_set_iam_policy` interceptor. The (possibly modified) response returned by
773 `post_set_iam_policy` will be passed to
774 `post_set_iam_policy_with_metadata`.
775 """
776 return response, metadata
778 def pre_test_iam_permissions(
779 self,
780 request: iam_policy_pb2.TestIamPermissionsRequest,
781 metadata: Sequence[Tuple[str, Union[str, bytes]]],
782 ) -> Tuple[
783 iam_policy_pb2.TestIamPermissionsRequest,
784 Sequence[Tuple[str, Union[str, bytes]]],
785 ]:
786 """Pre-rpc interceptor for test_iam_permissions
788 Override in a subclass to manipulate the request or metadata
789 before they are sent to the SecretManagerService server.
790 """
791 return request, metadata
793 def post_test_iam_permissions(
794 self, response: iam_policy_pb2.TestIamPermissionsResponse
795 ) -> iam_policy_pb2.TestIamPermissionsResponse:
796 """Post-rpc interceptor for test_iam_permissions
798 DEPRECATED. Please use the `post_test_iam_permissions_with_metadata`
799 interceptor instead.
801 Override in a subclass to read or manipulate the response
802 after it is returned by the SecretManagerService server but before
803 it is returned to user code. This `post_test_iam_permissions` interceptor runs
804 before the `post_test_iam_permissions_with_metadata` interceptor.
805 """
806 return response
808 def post_test_iam_permissions_with_metadata(
809 self,
810 response: iam_policy_pb2.TestIamPermissionsResponse,
811 metadata: Sequence[Tuple[str, Union[str, bytes]]],
812 ) -> Tuple[
813 iam_policy_pb2.TestIamPermissionsResponse,
814 Sequence[Tuple[str, Union[str, bytes]]],
815 ]:
816 """Post-rpc interceptor for test_iam_permissions
818 Override in a subclass to read or manipulate the response or metadata after it
819 is returned by the SecretManagerService server but before it is returned to user code.
821 We recommend only using this `post_test_iam_permissions_with_metadata`
822 interceptor in new development instead of the `post_test_iam_permissions` interceptor.
823 When both interceptors are used, this `post_test_iam_permissions_with_metadata` interceptor runs after the
824 `post_test_iam_permissions` interceptor. The (possibly modified) response returned by
825 `post_test_iam_permissions` will be passed to
826 `post_test_iam_permissions_with_metadata`.
827 """
828 return response, metadata
830 def pre_update_secret(
831 self,
832 request: service.UpdateSecretRequest,
833 metadata: Sequence[Tuple[str, Union[str, bytes]]],
834 ) -> Tuple[service.UpdateSecretRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
835 """Pre-rpc interceptor for update_secret
837 Override in a subclass to manipulate the request or metadata
838 before they are sent to the SecretManagerService server.
839 """
840 return request, metadata
842 def post_update_secret(self, response: resources.Secret) -> resources.Secret:
843 """Post-rpc interceptor for update_secret
845 DEPRECATED. Please use the `post_update_secret_with_metadata`
846 interceptor instead.
848 Override in a subclass to read or manipulate the response
849 after it is returned by the SecretManagerService server but before
850 it is returned to user code. This `post_update_secret` interceptor runs
851 before the `post_update_secret_with_metadata` interceptor.
852 """
853 return response
855 def post_update_secret_with_metadata(
856 self,
857 response: resources.Secret,
858 metadata: Sequence[Tuple[str, Union[str, bytes]]],
859 ) -> Tuple[resources.Secret, Sequence[Tuple[str, Union[str, bytes]]]]:
860 """Post-rpc interceptor for update_secret
862 Override in a subclass to read or manipulate the response or metadata after it
863 is returned by the SecretManagerService server but before it is returned to user code.
865 We recommend only using this `post_update_secret_with_metadata`
866 interceptor in new development instead of the `post_update_secret` interceptor.
867 When both interceptors are used, this `post_update_secret_with_metadata` interceptor runs after the
868 `post_update_secret` interceptor. The (possibly modified) response returned by
869 `post_update_secret` will be passed to
870 `post_update_secret_with_metadata`.
871 """
872 return response, metadata
874 def pre_get_location(
875 self,
876 request: locations_pb2.GetLocationRequest,
877 metadata: Sequence[Tuple[str, Union[str, bytes]]],
878 ) -> Tuple[
879 locations_pb2.GetLocationRequest, Sequence[Tuple[str, Union[str, bytes]]]
880 ]:
881 """Pre-rpc interceptor for get_location
883 Override in a subclass to manipulate the request or metadata
884 before they are sent to the SecretManagerService server.
885 """
886 return request, metadata
888 def post_get_location(
889 self, response: locations_pb2.Location
890 ) -> locations_pb2.Location:
891 """Post-rpc interceptor for get_location
893 Override in a subclass to manipulate the response
894 after it is returned by the SecretManagerService server but before
895 it is returned to user code.
896 """
897 return response
899 def pre_list_locations(
900 self,
901 request: locations_pb2.ListLocationsRequest,
902 metadata: Sequence[Tuple[str, Union[str, bytes]]],
903 ) -> Tuple[
904 locations_pb2.ListLocationsRequest, Sequence[Tuple[str, Union[str, bytes]]]
905 ]:
906 """Pre-rpc interceptor for list_locations
908 Override in a subclass to manipulate the request or metadata
909 before they are sent to the SecretManagerService server.
910 """
911 return request, metadata
913 def post_list_locations(
914 self, response: locations_pb2.ListLocationsResponse
915 ) -> locations_pb2.ListLocationsResponse:
916 """Post-rpc interceptor for list_locations
918 Override in a subclass to manipulate the response
919 after it is returned by the SecretManagerService server but before
920 it is returned to user code.
921 """
922 return response
925@dataclasses.dataclass
926class SecretManagerServiceRestStub:
927 _session: AuthorizedSession
928 _host: str
929 _interceptor: SecretManagerServiceRestInterceptor
932class SecretManagerServiceRestTransport(_BaseSecretManagerServiceRestTransport):
933 """REST backend synchronous transport for SecretManagerService.
935 Secret Manager Service
937 Manages secrets and operations using those secrets. Implements a
938 REST model with the following objects:
940 - [Secret][google.cloud.secrets.v1beta1.Secret]
941 - [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]
943 This class defines the same methods as the primary client, so the
944 primary client can load the underlying transport implementation
945 and call it.
947 It sends JSON representations of protocol buffers over HTTP/1.1
948 """
950 def __init__(
951 self,
952 *,
953 host: str = "secretmanager.googleapis.com",
954 credentials: Optional[ga_credentials.Credentials] = None,
955 credentials_file: Optional[str] = None,
956 scopes: Optional[Sequence[str]] = None,
957 client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
958 quota_project_id: Optional[str] = None,
959 client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
960 always_use_jwt_access: Optional[bool] = False,
961 url_scheme: str = "https",
962 interceptor: Optional[SecretManagerServiceRestInterceptor] = None,
963 api_audience: Optional[str] = None,
964 ) -> None:
965 """Instantiate the transport.
967 Args:
968 host (Optional[str]):
969 The hostname to connect to (default: 'secretmanager.googleapis.com').
970 credentials (Optional[google.auth.credentials.Credentials]): The
971 authorization credentials to attach to requests. These
972 credentials identify the application to the service; if none
973 are specified, the client will attempt to ascertain the
974 credentials from the environment.
976 credentials_file (Optional[str]): Deprecated. A file with credentials that can
977 be loaded with :func:`google.auth.load_credentials_from_file`.
978 This argument is ignored if ``channel`` is provided. This argument will be
979 removed in the next major version of this library.
980 scopes (Optional(Sequence[str])): A list of scopes. This argument is
981 ignored if ``channel`` is provided.
982 client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
983 certificate to configure mutual TLS HTTP channel. It is ignored
984 if ``channel`` is provided.
985 quota_project_id (Optional[str]): An optional project to use for billing
986 and quota.
987 client_info (google.api_core.gapic_v1.client_info.ClientInfo):
988 The client info used to send a user-agent string along with
989 API requests. If ``None``, then default info will be used.
990 Generally, you only need to set this if you are developing
991 your own client library.
992 always_use_jwt_access (Optional[bool]): Whether self signed JWT should
993 be used for service account credentials.
994 url_scheme: the protocol scheme for the API endpoint. Normally
995 "https", but for testing or local servers,
996 "http" can be specified.
997 interceptor (Optional[SecretManagerServiceRestInterceptor]): Interceptor used
998 to manipulate requests, request metadata, and responses.
999 api_audience (Optional[str]): The intended audience for the API calls
1000 to the service that will be set when using certain 3rd party
1001 authentication flows. Audience is typically a resource identifier.
1002 If not set, the host value will be used as a default.
1003 """
1004 # Run the base constructor
1005 # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
1006 # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
1007 # credentials object
1008 super().__init__(
1009 host=host,
1010 credentials=credentials,
1011 client_info=client_info,
1012 always_use_jwt_access=always_use_jwt_access,
1013 url_scheme=url_scheme,
1014 api_audience=api_audience,
1015 )
1016 self._session = AuthorizedSession(
1017 self._credentials, default_host=self.DEFAULT_HOST
1018 )
1019 if client_cert_source_for_mtls:
1020 self._session.configure_mtls_channel(client_cert_source_for_mtls)
1021 self._interceptor = interceptor or SecretManagerServiceRestInterceptor()
1022 self._prep_wrapped_messages(client_info)
1024 class _AccessSecretVersion(
1025 _BaseSecretManagerServiceRestTransport._BaseAccessSecretVersion,
1026 SecretManagerServiceRestStub,
1027 ):
1028 def __hash__(self):
1029 return hash("SecretManagerServiceRestTransport.AccessSecretVersion")
1031 @staticmethod
1032 def _get_response(
1033 host,
1034 metadata,
1035 query_params,
1036 session,
1037 timeout,
1038 transcoded_request,
1039 body=None,
1040 ):
1041 uri = transcoded_request["uri"]
1042 method = transcoded_request["method"]
1043 headers = dict(metadata)
1044 headers["Content-Type"] = "application/json"
1045 response = getattr(session, method)(
1046 "{host}{uri}".format(host=host, uri=uri),
1047 timeout=timeout,
1048 headers=headers,
1049 params=rest_helpers.flatten_query_params(query_params, strict=True),
1050 )
1051 return response
1053 def __call__(
1054 self,
1055 request: service.AccessSecretVersionRequest,
1056 *,
1057 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1058 timeout: Optional[float] = None,
1059 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1060 ) -> service.AccessSecretVersionResponse:
1061 r"""Call the access secret version method over HTTP.
1063 Args:
1064 request (~.service.AccessSecretVersionRequest):
1065 The request object. Request message for
1066 [SecretManagerService.AccessSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.AccessSecretVersion].
1067 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1068 should be retried.
1069 timeout (float): The timeout for this request.
1070 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1071 sent along with the request as metadata. Normally, each value must be of type `str`,
1072 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1073 be of type `bytes`.
1075 Returns:
1076 ~.service.AccessSecretVersionResponse:
1077 Response message for
1078 [SecretManagerService.AccessSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.AccessSecretVersion].
1080 """
1082 http_options = _BaseSecretManagerServiceRestTransport._BaseAccessSecretVersion._get_http_options()
1084 request, metadata = self._interceptor.pre_access_secret_version(
1085 request, metadata
1086 )
1087 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseAccessSecretVersion._get_transcoded_request(
1088 http_options, request
1089 )
1091 # Jsonify the query params
1092 query_params = _BaseSecretManagerServiceRestTransport._BaseAccessSecretVersion._get_query_params_json(
1093 transcoded_request
1094 )
1096 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1097 logging.DEBUG
1098 ): # pragma: NO COVER
1099 request_url = "{host}{uri}".format(
1100 host=self._host, uri=transcoded_request["uri"]
1101 )
1102 method = transcoded_request["method"]
1103 try:
1104 request_payload = type(request).to_json(request)
1105 except:
1106 request_payload = None
1107 http_request = {
1108 "payload": request_payload,
1109 "requestMethod": method,
1110 "requestUrl": request_url,
1111 "headers": dict(metadata),
1112 }
1113 _LOGGER.debug(
1114 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.AccessSecretVersion",
1115 extra={
1116 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1117 "rpcName": "AccessSecretVersion",
1118 "httpRequest": http_request,
1119 "metadata": http_request["headers"],
1120 },
1121 )
1123 # Send the request
1124 response = (
1125 SecretManagerServiceRestTransport._AccessSecretVersion._get_response(
1126 self._host,
1127 metadata,
1128 query_params,
1129 self._session,
1130 timeout,
1131 transcoded_request,
1132 )
1133 )
1135 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1136 # subclass.
1137 if response.status_code >= 400:
1138 raise core_exceptions.from_http_response(response)
1140 # Return the response
1141 resp = service.AccessSecretVersionResponse()
1142 pb_resp = service.AccessSecretVersionResponse.pb(resp)
1144 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1146 resp = self._interceptor.post_access_secret_version(resp)
1147 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1148 resp, _ = self._interceptor.post_access_secret_version_with_metadata(
1149 resp, response_metadata
1150 )
1151 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1152 logging.DEBUG
1153 ): # pragma: NO COVER
1154 try:
1155 response_payload = service.AccessSecretVersionResponse.to_json(
1156 response
1157 )
1158 except:
1159 response_payload = None
1160 http_response = {
1161 "payload": response_payload,
1162 "headers": dict(response.headers),
1163 "status": response.status_code,
1164 }
1165 _LOGGER.debug(
1166 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.access_secret_version",
1167 extra={
1168 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1169 "rpcName": "AccessSecretVersion",
1170 "metadata": http_response["headers"],
1171 "httpResponse": http_response,
1172 },
1173 )
1174 return resp
1176 class _AddSecretVersion(
1177 _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion,
1178 SecretManagerServiceRestStub,
1179 ):
1180 def __hash__(self):
1181 return hash("SecretManagerServiceRestTransport.AddSecretVersion")
1183 @staticmethod
1184 def _get_response(
1185 host,
1186 metadata,
1187 query_params,
1188 session,
1189 timeout,
1190 transcoded_request,
1191 body=None,
1192 ):
1193 uri = transcoded_request["uri"]
1194 method = transcoded_request["method"]
1195 headers = dict(metadata)
1196 headers["Content-Type"] = "application/json"
1197 response = getattr(session, method)(
1198 "{host}{uri}".format(host=host, uri=uri),
1199 timeout=timeout,
1200 headers=headers,
1201 params=rest_helpers.flatten_query_params(query_params, strict=True),
1202 data=body,
1203 )
1204 return response
1206 def __call__(
1207 self,
1208 request: service.AddSecretVersionRequest,
1209 *,
1210 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1211 timeout: Optional[float] = None,
1212 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1213 ) -> resources.SecretVersion:
1214 r"""Call the add secret version method over HTTP.
1216 Args:
1217 request (~.service.AddSecretVersionRequest):
1218 The request object. Request message for
1219 [SecretManagerService.AddSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.AddSecretVersion].
1220 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1221 should be retried.
1222 timeout (float): The timeout for this request.
1223 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1224 sent along with the request as metadata. Normally, each value must be of type `str`,
1225 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1226 be of type `bytes`.
1228 Returns:
1229 ~.resources.SecretVersion:
1230 A secret version resource in the
1231 Secret Manager API.
1233 """
1235 http_options = _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion._get_http_options()
1237 request, metadata = self._interceptor.pre_add_secret_version(
1238 request, metadata
1239 )
1240 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion._get_transcoded_request(
1241 http_options, request
1242 )
1244 body = _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion._get_request_body_json(
1245 transcoded_request
1246 )
1248 # Jsonify the query params
1249 query_params = _BaseSecretManagerServiceRestTransport._BaseAddSecretVersion._get_query_params_json(
1250 transcoded_request
1251 )
1253 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1254 logging.DEBUG
1255 ): # pragma: NO COVER
1256 request_url = "{host}{uri}".format(
1257 host=self._host, uri=transcoded_request["uri"]
1258 )
1259 method = transcoded_request["method"]
1260 try:
1261 request_payload = type(request).to_json(request)
1262 except:
1263 request_payload = None
1264 http_request = {
1265 "payload": request_payload,
1266 "requestMethod": method,
1267 "requestUrl": request_url,
1268 "headers": dict(metadata),
1269 }
1270 _LOGGER.debug(
1271 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.AddSecretVersion",
1272 extra={
1273 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1274 "rpcName": "AddSecretVersion",
1275 "httpRequest": http_request,
1276 "metadata": http_request["headers"],
1277 },
1278 )
1280 # Send the request
1281 response = (
1282 SecretManagerServiceRestTransport._AddSecretVersion._get_response(
1283 self._host,
1284 metadata,
1285 query_params,
1286 self._session,
1287 timeout,
1288 transcoded_request,
1289 body,
1290 )
1291 )
1293 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1294 # subclass.
1295 if response.status_code >= 400:
1296 raise core_exceptions.from_http_response(response)
1298 # Return the response
1299 resp = resources.SecretVersion()
1300 pb_resp = resources.SecretVersion.pb(resp)
1302 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1304 resp = self._interceptor.post_add_secret_version(resp)
1305 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1306 resp, _ = self._interceptor.post_add_secret_version_with_metadata(
1307 resp, response_metadata
1308 )
1309 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1310 logging.DEBUG
1311 ): # pragma: NO COVER
1312 try:
1313 response_payload = resources.SecretVersion.to_json(response)
1314 except:
1315 response_payload = None
1316 http_response = {
1317 "payload": response_payload,
1318 "headers": dict(response.headers),
1319 "status": response.status_code,
1320 }
1321 _LOGGER.debug(
1322 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.add_secret_version",
1323 extra={
1324 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1325 "rpcName": "AddSecretVersion",
1326 "metadata": http_response["headers"],
1327 "httpResponse": http_response,
1328 },
1329 )
1330 return resp
1332 class _CreateSecret(
1333 _BaseSecretManagerServiceRestTransport._BaseCreateSecret,
1334 SecretManagerServiceRestStub,
1335 ):
1336 def __hash__(self):
1337 return hash("SecretManagerServiceRestTransport.CreateSecret")
1339 @staticmethod
1340 def _get_response(
1341 host,
1342 metadata,
1343 query_params,
1344 session,
1345 timeout,
1346 transcoded_request,
1347 body=None,
1348 ):
1349 uri = transcoded_request["uri"]
1350 method = transcoded_request["method"]
1351 headers = dict(metadata)
1352 headers["Content-Type"] = "application/json"
1353 response = getattr(session, method)(
1354 "{host}{uri}".format(host=host, uri=uri),
1355 timeout=timeout,
1356 headers=headers,
1357 params=rest_helpers.flatten_query_params(query_params, strict=True),
1358 data=body,
1359 )
1360 return response
1362 def __call__(
1363 self,
1364 request: service.CreateSecretRequest,
1365 *,
1366 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1367 timeout: Optional[float] = None,
1368 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1369 ) -> resources.Secret:
1370 r"""Call the create secret method over HTTP.
1372 Args:
1373 request (~.service.CreateSecretRequest):
1374 The request object. Request message for
1375 [SecretManagerService.CreateSecret][google.cloud.secrets.v1beta1.SecretManagerService.CreateSecret].
1376 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1377 should be retried.
1378 timeout (float): The timeout for this request.
1379 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1380 sent along with the request as metadata. Normally, each value must be of type `str`,
1381 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1382 be of type `bytes`.
1384 Returns:
1385 ~.resources.Secret:
1386 A [Secret][google.cloud.secrets.v1beta1.Secret] is a
1387 logical secret whose value and versions can be accessed.
1389 A [Secret][google.cloud.secrets.v1beta1.Secret] is made
1390 up of zero or more
1391 [SecretVersions][google.cloud.secrets.v1beta1.SecretVersion]
1392 that represent the secret data.
1394 """
1396 http_options = _BaseSecretManagerServiceRestTransport._BaseCreateSecret._get_http_options()
1398 request, metadata = self._interceptor.pre_create_secret(request, metadata)
1399 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseCreateSecret._get_transcoded_request(
1400 http_options, request
1401 )
1403 body = _BaseSecretManagerServiceRestTransport._BaseCreateSecret._get_request_body_json(
1404 transcoded_request
1405 )
1407 # Jsonify the query params
1408 query_params = _BaseSecretManagerServiceRestTransport._BaseCreateSecret._get_query_params_json(
1409 transcoded_request
1410 )
1412 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1413 logging.DEBUG
1414 ): # pragma: NO COVER
1415 request_url = "{host}{uri}".format(
1416 host=self._host, uri=transcoded_request["uri"]
1417 )
1418 method = transcoded_request["method"]
1419 try:
1420 request_payload = type(request).to_json(request)
1421 except:
1422 request_payload = None
1423 http_request = {
1424 "payload": request_payload,
1425 "requestMethod": method,
1426 "requestUrl": request_url,
1427 "headers": dict(metadata),
1428 }
1429 _LOGGER.debug(
1430 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.CreateSecret",
1431 extra={
1432 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1433 "rpcName": "CreateSecret",
1434 "httpRequest": http_request,
1435 "metadata": http_request["headers"],
1436 },
1437 )
1439 # Send the request
1440 response = SecretManagerServiceRestTransport._CreateSecret._get_response(
1441 self._host,
1442 metadata,
1443 query_params,
1444 self._session,
1445 timeout,
1446 transcoded_request,
1447 body,
1448 )
1450 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1451 # subclass.
1452 if response.status_code >= 400:
1453 raise core_exceptions.from_http_response(response)
1455 # Return the response
1456 resp = resources.Secret()
1457 pb_resp = resources.Secret.pb(resp)
1459 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1461 resp = self._interceptor.post_create_secret(resp)
1462 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1463 resp, _ = self._interceptor.post_create_secret_with_metadata(
1464 resp, response_metadata
1465 )
1466 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1467 logging.DEBUG
1468 ): # pragma: NO COVER
1469 try:
1470 response_payload = resources.Secret.to_json(response)
1471 except:
1472 response_payload = None
1473 http_response = {
1474 "payload": response_payload,
1475 "headers": dict(response.headers),
1476 "status": response.status_code,
1477 }
1478 _LOGGER.debug(
1479 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.create_secret",
1480 extra={
1481 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1482 "rpcName": "CreateSecret",
1483 "metadata": http_response["headers"],
1484 "httpResponse": http_response,
1485 },
1486 )
1487 return resp
1489 class _DeleteSecret(
1490 _BaseSecretManagerServiceRestTransport._BaseDeleteSecret,
1491 SecretManagerServiceRestStub,
1492 ):
1493 def __hash__(self):
1494 return hash("SecretManagerServiceRestTransport.DeleteSecret")
1496 @staticmethod
1497 def _get_response(
1498 host,
1499 metadata,
1500 query_params,
1501 session,
1502 timeout,
1503 transcoded_request,
1504 body=None,
1505 ):
1506 uri = transcoded_request["uri"]
1507 method = transcoded_request["method"]
1508 headers = dict(metadata)
1509 headers["Content-Type"] = "application/json"
1510 response = getattr(session, method)(
1511 "{host}{uri}".format(host=host, uri=uri),
1512 timeout=timeout,
1513 headers=headers,
1514 params=rest_helpers.flatten_query_params(query_params, strict=True),
1515 )
1516 return response
1518 def __call__(
1519 self,
1520 request: service.DeleteSecretRequest,
1521 *,
1522 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1523 timeout: Optional[float] = None,
1524 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1525 ):
1526 r"""Call the delete secret method over HTTP.
1528 Args:
1529 request (~.service.DeleteSecretRequest):
1530 The request object. Request message for
1531 [SecretManagerService.DeleteSecret][google.cloud.secrets.v1beta1.SecretManagerService.DeleteSecret].
1532 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1533 should be retried.
1534 timeout (float): The timeout for this request.
1535 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1536 sent along with the request as metadata. Normally, each value must be of type `str`,
1537 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1538 be of type `bytes`.
1539 """
1541 http_options = _BaseSecretManagerServiceRestTransport._BaseDeleteSecret._get_http_options()
1543 request, metadata = self._interceptor.pre_delete_secret(request, metadata)
1544 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseDeleteSecret._get_transcoded_request(
1545 http_options, request
1546 )
1548 # Jsonify the query params
1549 query_params = _BaseSecretManagerServiceRestTransport._BaseDeleteSecret._get_query_params_json(
1550 transcoded_request
1551 )
1553 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1554 logging.DEBUG
1555 ): # pragma: NO COVER
1556 request_url = "{host}{uri}".format(
1557 host=self._host, uri=transcoded_request["uri"]
1558 )
1559 method = transcoded_request["method"]
1560 try:
1561 request_payload = type(request).to_json(request)
1562 except:
1563 request_payload = None
1564 http_request = {
1565 "payload": request_payload,
1566 "requestMethod": method,
1567 "requestUrl": request_url,
1568 "headers": dict(metadata),
1569 }
1570 _LOGGER.debug(
1571 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.DeleteSecret",
1572 extra={
1573 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1574 "rpcName": "DeleteSecret",
1575 "httpRequest": http_request,
1576 "metadata": http_request["headers"],
1577 },
1578 )
1580 # Send the request
1581 response = SecretManagerServiceRestTransport._DeleteSecret._get_response(
1582 self._host,
1583 metadata,
1584 query_params,
1585 self._session,
1586 timeout,
1587 transcoded_request,
1588 )
1590 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1591 # subclass.
1592 if response.status_code >= 400:
1593 raise core_exceptions.from_http_response(response)
1595 class _DestroySecretVersion(
1596 _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion,
1597 SecretManagerServiceRestStub,
1598 ):
1599 def __hash__(self):
1600 return hash("SecretManagerServiceRestTransport.DestroySecretVersion")
1602 @staticmethod
1603 def _get_response(
1604 host,
1605 metadata,
1606 query_params,
1607 session,
1608 timeout,
1609 transcoded_request,
1610 body=None,
1611 ):
1612 uri = transcoded_request["uri"]
1613 method = transcoded_request["method"]
1614 headers = dict(metadata)
1615 headers["Content-Type"] = "application/json"
1616 response = getattr(session, method)(
1617 "{host}{uri}".format(host=host, uri=uri),
1618 timeout=timeout,
1619 headers=headers,
1620 params=rest_helpers.flatten_query_params(query_params, strict=True),
1621 data=body,
1622 )
1623 return response
1625 def __call__(
1626 self,
1627 request: service.DestroySecretVersionRequest,
1628 *,
1629 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1630 timeout: Optional[float] = None,
1631 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1632 ) -> resources.SecretVersion:
1633 r"""Call the destroy secret version method over HTTP.
1635 Args:
1636 request (~.service.DestroySecretVersionRequest):
1637 The request object. Request message for
1638 [SecretManagerService.DestroySecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.DestroySecretVersion].
1639 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1640 should be retried.
1641 timeout (float): The timeout for this request.
1642 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1643 sent along with the request as metadata. Normally, each value must be of type `str`,
1644 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1645 be of type `bytes`.
1647 Returns:
1648 ~.resources.SecretVersion:
1649 A secret version resource in the
1650 Secret Manager API.
1652 """
1654 http_options = _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion._get_http_options()
1656 request, metadata = self._interceptor.pre_destroy_secret_version(
1657 request, metadata
1658 )
1659 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion._get_transcoded_request(
1660 http_options, request
1661 )
1663 body = _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion._get_request_body_json(
1664 transcoded_request
1665 )
1667 # Jsonify the query params
1668 query_params = _BaseSecretManagerServiceRestTransport._BaseDestroySecretVersion._get_query_params_json(
1669 transcoded_request
1670 )
1672 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1673 logging.DEBUG
1674 ): # pragma: NO COVER
1675 request_url = "{host}{uri}".format(
1676 host=self._host, uri=transcoded_request["uri"]
1677 )
1678 method = transcoded_request["method"]
1679 try:
1680 request_payload = type(request).to_json(request)
1681 except:
1682 request_payload = None
1683 http_request = {
1684 "payload": request_payload,
1685 "requestMethod": method,
1686 "requestUrl": request_url,
1687 "headers": dict(metadata),
1688 }
1689 _LOGGER.debug(
1690 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.DestroySecretVersion",
1691 extra={
1692 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1693 "rpcName": "DestroySecretVersion",
1694 "httpRequest": http_request,
1695 "metadata": http_request["headers"],
1696 },
1697 )
1699 # Send the request
1700 response = (
1701 SecretManagerServiceRestTransport._DestroySecretVersion._get_response(
1702 self._host,
1703 metadata,
1704 query_params,
1705 self._session,
1706 timeout,
1707 transcoded_request,
1708 body,
1709 )
1710 )
1712 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1713 # subclass.
1714 if response.status_code >= 400:
1715 raise core_exceptions.from_http_response(response)
1717 # Return the response
1718 resp = resources.SecretVersion()
1719 pb_resp = resources.SecretVersion.pb(resp)
1721 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1723 resp = self._interceptor.post_destroy_secret_version(resp)
1724 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1725 resp, _ = self._interceptor.post_destroy_secret_version_with_metadata(
1726 resp, response_metadata
1727 )
1728 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1729 logging.DEBUG
1730 ): # pragma: NO COVER
1731 try:
1732 response_payload = resources.SecretVersion.to_json(response)
1733 except:
1734 response_payload = None
1735 http_response = {
1736 "payload": response_payload,
1737 "headers": dict(response.headers),
1738 "status": response.status_code,
1739 }
1740 _LOGGER.debug(
1741 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.destroy_secret_version",
1742 extra={
1743 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1744 "rpcName": "DestroySecretVersion",
1745 "metadata": http_response["headers"],
1746 "httpResponse": http_response,
1747 },
1748 )
1749 return resp
1751 class _DisableSecretVersion(
1752 _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion,
1753 SecretManagerServiceRestStub,
1754 ):
1755 def __hash__(self):
1756 return hash("SecretManagerServiceRestTransport.DisableSecretVersion")
1758 @staticmethod
1759 def _get_response(
1760 host,
1761 metadata,
1762 query_params,
1763 session,
1764 timeout,
1765 transcoded_request,
1766 body=None,
1767 ):
1768 uri = transcoded_request["uri"]
1769 method = transcoded_request["method"]
1770 headers = dict(metadata)
1771 headers["Content-Type"] = "application/json"
1772 response = getattr(session, method)(
1773 "{host}{uri}".format(host=host, uri=uri),
1774 timeout=timeout,
1775 headers=headers,
1776 params=rest_helpers.flatten_query_params(query_params, strict=True),
1777 data=body,
1778 )
1779 return response
1781 def __call__(
1782 self,
1783 request: service.DisableSecretVersionRequest,
1784 *,
1785 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1786 timeout: Optional[float] = None,
1787 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1788 ) -> resources.SecretVersion:
1789 r"""Call the disable secret version method over HTTP.
1791 Args:
1792 request (~.service.DisableSecretVersionRequest):
1793 The request object. Request message for
1794 [SecretManagerService.DisableSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.DisableSecretVersion].
1795 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1796 should be retried.
1797 timeout (float): The timeout for this request.
1798 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1799 sent along with the request as metadata. Normally, each value must be of type `str`,
1800 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1801 be of type `bytes`.
1803 Returns:
1804 ~.resources.SecretVersion:
1805 A secret version resource in the
1806 Secret Manager API.
1808 """
1810 http_options = _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion._get_http_options()
1812 request, metadata = self._interceptor.pre_disable_secret_version(
1813 request, metadata
1814 )
1815 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion._get_transcoded_request(
1816 http_options, request
1817 )
1819 body = _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion._get_request_body_json(
1820 transcoded_request
1821 )
1823 # Jsonify the query params
1824 query_params = _BaseSecretManagerServiceRestTransport._BaseDisableSecretVersion._get_query_params_json(
1825 transcoded_request
1826 )
1828 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1829 logging.DEBUG
1830 ): # pragma: NO COVER
1831 request_url = "{host}{uri}".format(
1832 host=self._host, uri=transcoded_request["uri"]
1833 )
1834 method = transcoded_request["method"]
1835 try:
1836 request_payload = type(request).to_json(request)
1837 except:
1838 request_payload = None
1839 http_request = {
1840 "payload": request_payload,
1841 "requestMethod": method,
1842 "requestUrl": request_url,
1843 "headers": dict(metadata),
1844 }
1845 _LOGGER.debug(
1846 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.DisableSecretVersion",
1847 extra={
1848 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1849 "rpcName": "DisableSecretVersion",
1850 "httpRequest": http_request,
1851 "metadata": http_request["headers"],
1852 },
1853 )
1855 # Send the request
1856 response = (
1857 SecretManagerServiceRestTransport._DisableSecretVersion._get_response(
1858 self._host,
1859 metadata,
1860 query_params,
1861 self._session,
1862 timeout,
1863 transcoded_request,
1864 body,
1865 )
1866 )
1868 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
1869 # subclass.
1870 if response.status_code >= 400:
1871 raise core_exceptions.from_http_response(response)
1873 # Return the response
1874 resp = resources.SecretVersion()
1875 pb_resp = resources.SecretVersion.pb(resp)
1877 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
1879 resp = self._interceptor.post_disable_secret_version(resp)
1880 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
1881 resp, _ = self._interceptor.post_disable_secret_version_with_metadata(
1882 resp, response_metadata
1883 )
1884 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1885 logging.DEBUG
1886 ): # pragma: NO COVER
1887 try:
1888 response_payload = resources.SecretVersion.to_json(response)
1889 except:
1890 response_payload = None
1891 http_response = {
1892 "payload": response_payload,
1893 "headers": dict(response.headers),
1894 "status": response.status_code,
1895 }
1896 _LOGGER.debug(
1897 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.disable_secret_version",
1898 extra={
1899 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
1900 "rpcName": "DisableSecretVersion",
1901 "metadata": http_response["headers"],
1902 "httpResponse": http_response,
1903 },
1904 )
1905 return resp
1907 class _EnableSecretVersion(
1908 _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion,
1909 SecretManagerServiceRestStub,
1910 ):
1911 def __hash__(self):
1912 return hash("SecretManagerServiceRestTransport.EnableSecretVersion")
1914 @staticmethod
1915 def _get_response(
1916 host,
1917 metadata,
1918 query_params,
1919 session,
1920 timeout,
1921 transcoded_request,
1922 body=None,
1923 ):
1924 uri = transcoded_request["uri"]
1925 method = transcoded_request["method"]
1926 headers = dict(metadata)
1927 headers["Content-Type"] = "application/json"
1928 response = getattr(session, method)(
1929 "{host}{uri}".format(host=host, uri=uri),
1930 timeout=timeout,
1931 headers=headers,
1932 params=rest_helpers.flatten_query_params(query_params, strict=True),
1933 data=body,
1934 )
1935 return response
1937 def __call__(
1938 self,
1939 request: service.EnableSecretVersionRequest,
1940 *,
1941 retry: OptionalRetry = gapic_v1.method.DEFAULT,
1942 timeout: Optional[float] = None,
1943 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
1944 ) -> resources.SecretVersion:
1945 r"""Call the enable secret version method over HTTP.
1947 Args:
1948 request (~.service.EnableSecretVersionRequest):
1949 The request object. Request message for
1950 [SecretManagerService.EnableSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.EnableSecretVersion].
1951 retry (google.api_core.retry.Retry): Designation of what errors, if any,
1952 should be retried.
1953 timeout (float): The timeout for this request.
1954 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
1955 sent along with the request as metadata. Normally, each value must be of type `str`,
1956 but for metadata keys ending with the suffix `-bin`, the corresponding values must
1957 be of type `bytes`.
1959 Returns:
1960 ~.resources.SecretVersion:
1961 A secret version resource in the
1962 Secret Manager API.
1964 """
1966 http_options = _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion._get_http_options()
1968 request, metadata = self._interceptor.pre_enable_secret_version(
1969 request, metadata
1970 )
1971 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion._get_transcoded_request(
1972 http_options, request
1973 )
1975 body = _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion._get_request_body_json(
1976 transcoded_request
1977 )
1979 # Jsonify the query params
1980 query_params = _BaseSecretManagerServiceRestTransport._BaseEnableSecretVersion._get_query_params_json(
1981 transcoded_request
1982 )
1984 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
1985 logging.DEBUG
1986 ): # pragma: NO COVER
1987 request_url = "{host}{uri}".format(
1988 host=self._host, uri=transcoded_request["uri"]
1989 )
1990 method = transcoded_request["method"]
1991 try:
1992 request_payload = type(request).to_json(request)
1993 except:
1994 request_payload = None
1995 http_request = {
1996 "payload": request_payload,
1997 "requestMethod": method,
1998 "requestUrl": request_url,
1999 "headers": dict(metadata),
2000 }
2001 _LOGGER.debug(
2002 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.EnableSecretVersion",
2003 extra={
2004 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2005 "rpcName": "EnableSecretVersion",
2006 "httpRequest": http_request,
2007 "metadata": http_request["headers"],
2008 },
2009 )
2011 # Send the request
2012 response = (
2013 SecretManagerServiceRestTransport._EnableSecretVersion._get_response(
2014 self._host,
2015 metadata,
2016 query_params,
2017 self._session,
2018 timeout,
2019 transcoded_request,
2020 body,
2021 )
2022 )
2024 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2025 # subclass.
2026 if response.status_code >= 400:
2027 raise core_exceptions.from_http_response(response)
2029 # Return the response
2030 resp = resources.SecretVersion()
2031 pb_resp = resources.SecretVersion.pb(resp)
2033 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2035 resp = self._interceptor.post_enable_secret_version(resp)
2036 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2037 resp, _ = self._interceptor.post_enable_secret_version_with_metadata(
2038 resp, response_metadata
2039 )
2040 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2041 logging.DEBUG
2042 ): # pragma: NO COVER
2043 try:
2044 response_payload = resources.SecretVersion.to_json(response)
2045 except:
2046 response_payload = None
2047 http_response = {
2048 "payload": response_payload,
2049 "headers": dict(response.headers),
2050 "status": response.status_code,
2051 }
2052 _LOGGER.debug(
2053 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.enable_secret_version",
2054 extra={
2055 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2056 "rpcName": "EnableSecretVersion",
2057 "metadata": http_response["headers"],
2058 "httpResponse": http_response,
2059 },
2060 )
2061 return resp
2063 class _GetIamPolicy(
2064 _BaseSecretManagerServiceRestTransport._BaseGetIamPolicy,
2065 SecretManagerServiceRestStub,
2066 ):
2067 def __hash__(self):
2068 return hash("SecretManagerServiceRestTransport.GetIamPolicy")
2070 @staticmethod
2071 def _get_response(
2072 host,
2073 metadata,
2074 query_params,
2075 session,
2076 timeout,
2077 transcoded_request,
2078 body=None,
2079 ):
2080 uri = transcoded_request["uri"]
2081 method = transcoded_request["method"]
2082 headers = dict(metadata)
2083 headers["Content-Type"] = "application/json"
2084 response = getattr(session, method)(
2085 "{host}{uri}".format(host=host, uri=uri),
2086 timeout=timeout,
2087 headers=headers,
2088 params=rest_helpers.flatten_query_params(query_params, strict=True),
2089 )
2090 return response
2092 def __call__(
2093 self,
2094 request: iam_policy_pb2.GetIamPolicyRequest,
2095 *,
2096 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2097 timeout: Optional[float] = None,
2098 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2099 ) -> policy_pb2.Policy:
2100 r"""Call the get iam policy method over HTTP.
2102 Args:
2103 request (~.iam_policy_pb2.GetIamPolicyRequest):
2104 The request object. Request message for ``GetIamPolicy`` method.
2105 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2106 should be retried.
2107 timeout (float): The timeout for this request.
2108 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2109 sent along with the request as metadata. Normally, each value must be of type `str`,
2110 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2111 be of type `bytes`.
2113 Returns:
2114 ~.policy_pb2.Policy:
2115 An Identity and Access Management (IAM) policy, which
2116 specifies access controls for Google Cloud resources.
2118 A ``Policy`` is a collection of ``bindings``. A
2119 ``binding`` binds one or more ``members``, or
2120 principals, to a single ``role``. Principals can be user
2121 accounts, service accounts, Google groups, and domains
2122 (such as G Suite). A ``role`` is a named list of
2123 permissions; each ``role`` can be an IAM predefined role
2124 or a user-created custom role.
2126 For some types of Google Cloud resources, a ``binding``
2127 can also specify a ``condition``, which is a logical
2128 expression that allows access to a resource only if the
2129 expression evaluates to ``true``. A condition can add
2130 constraints based on attributes of the request, the
2131 resource, or both. To learn which resources support
2132 conditions in their IAM policies, see the `IAM
2133 documentation <https://cloud.google.com/iam/help/conditions/resource-policies>`__.
2135 **JSON example:**
2137 ::
2139 {
2140 "bindings": [
2141 {
2142 "role": "roles/resourcemanager.organizationAdmin",
2143 "members": [
2144 "user:mike@example.com",
2145 "group:admins@example.com",
2146 "domain:google.com",
2147 "serviceAccount:my-project-id@appspot.gserviceaccount.com"
2148 ]
2149 },
2150 {
2151 "role": "roles/resourcemanager.organizationViewer",
2152 "members": [
2153 "user:eve@example.com"
2154 ],
2155 "condition": {
2156 "title": "expirable access",
2157 "description": "Does not grant access after Sep 2020",
2158 "expression": "request.time <
2159 timestamp('2020-10-01T00:00:00.000Z')",
2160 }
2161 }
2162 ],
2163 "etag": "BwWWja0YfJA=",
2164 "version": 3
2165 }
2167 **YAML example:**
2169 ::
2171 bindings:
2172 - members:
2173 - user:mike@example.com
2174 - group:admins@example.com
2175 - domain:google.com
2176 - serviceAccount:my-project-id@appspot.gserviceaccount.com
2177 role: roles/resourcemanager.organizationAdmin
2178 - members:
2179 - user:eve@example.com
2180 role: roles/resourcemanager.organizationViewer
2181 condition:
2182 title: expirable access
2183 description: Does not grant access after Sep 2020
2184 expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
2185 etag: BwWWja0YfJA=
2186 version: 3
2188 For a description of IAM and its features, see the `IAM
2189 documentation <https://cloud.google.com/iam/docs/>`__.
2191 """
2193 http_options = _BaseSecretManagerServiceRestTransport._BaseGetIamPolicy._get_http_options()
2195 request, metadata = self._interceptor.pre_get_iam_policy(request, metadata)
2196 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseGetIamPolicy._get_transcoded_request(
2197 http_options, request
2198 )
2200 # Jsonify the query params
2201 query_params = _BaseSecretManagerServiceRestTransport._BaseGetIamPolicy._get_query_params_json(
2202 transcoded_request
2203 )
2205 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2206 logging.DEBUG
2207 ): # pragma: NO COVER
2208 request_url = "{host}{uri}".format(
2209 host=self._host, uri=transcoded_request["uri"]
2210 )
2211 method = transcoded_request["method"]
2212 try:
2213 request_payload = json_format.MessageToJson(request)
2214 except:
2215 request_payload = None
2216 http_request = {
2217 "payload": request_payload,
2218 "requestMethod": method,
2219 "requestUrl": request_url,
2220 "headers": dict(metadata),
2221 }
2222 _LOGGER.debug(
2223 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.GetIamPolicy",
2224 extra={
2225 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2226 "rpcName": "GetIamPolicy",
2227 "httpRequest": http_request,
2228 "metadata": http_request["headers"],
2229 },
2230 )
2232 # Send the request
2233 response = SecretManagerServiceRestTransport._GetIamPolicy._get_response(
2234 self._host,
2235 metadata,
2236 query_params,
2237 self._session,
2238 timeout,
2239 transcoded_request,
2240 )
2242 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2243 # subclass.
2244 if response.status_code >= 400:
2245 raise core_exceptions.from_http_response(response)
2247 # Return the response
2248 resp = policy_pb2.Policy()
2249 pb_resp = resp
2251 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2253 resp = self._interceptor.post_get_iam_policy(resp)
2254 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2255 resp, _ = self._interceptor.post_get_iam_policy_with_metadata(
2256 resp, response_metadata
2257 )
2258 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2259 logging.DEBUG
2260 ): # pragma: NO COVER
2261 try:
2262 response_payload = json_format.MessageToJson(resp)
2263 except:
2264 response_payload = None
2265 http_response = {
2266 "payload": response_payload,
2267 "headers": dict(response.headers),
2268 "status": response.status_code,
2269 }
2270 _LOGGER.debug(
2271 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.get_iam_policy",
2272 extra={
2273 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2274 "rpcName": "GetIamPolicy",
2275 "metadata": http_response["headers"],
2276 "httpResponse": http_response,
2277 },
2278 )
2279 return resp
2281 class _GetSecret(
2282 _BaseSecretManagerServiceRestTransport._BaseGetSecret,
2283 SecretManagerServiceRestStub,
2284 ):
2285 def __hash__(self):
2286 return hash("SecretManagerServiceRestTransport.GetSecret")
2288 @staticmethod
2289 def _get_response(
2290 host,
2291 metadata,
2292 query_params,
2293 session,
2294 timeout,
2295 transcoded_request,
2296 body=None,
2297 ):
2298 uri = transcoded_request["uri"]
2299 method = transcoded_request["method"]
2300 headers = dict(metadata)
2301 headers["Content-Type"] = "application/json"
2302 response = getattr(session, method)(
2303 "{host}{uri}".format(host=host, uri=uri),
2304 timeout=timeout,
2305 headers=headers,
2306 params=rest_helpers.flatten_query_params(query_params, strict=True),
2307 )
2308 return response
2310 def __call__(
2311 self,
2312 request: service.GetSecretRequest,
2313 *,
2314 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2315 timeout: Optional[float] = None,
2316 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2317 ) -> resources.Secret:
2318 r"""Call the get secret method over HTTP.
2320 Args:
2321 request (~.service.GetSecretRequest):
2322 The request object. Request message for
2323 [SecretManagerService.GetSecret][google.cloud.secrets.v1beta1.SecretManagerService.GetSecret].
2324 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2325 should be retried.
2326 timeout (float): The timeout for this request.
2327 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2328 sent along with the request as metadata. Normally, each value must be of type `str`,
2329 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2330 be of type `bytes`.
2332 Returns:
2333 ~.resources.Secret:
2334 A [Secret][google.cloud.secrets.v1beta1.Secret] is a
2335 logical secret whose value and versions can be accessed.
2337 A [Secret][google.cloud.secrets.v1beta1.Secret] is made
2338 up of zero or more
2339 [SecretVersions][google.cloud.secrets.v1beta1.SecretVersion]
2340 that represent the secret data.
2342 """
2344 http_options = _BaseSecretManagerServiceRestTransport._BaseGetSecret._get_http_options()
2346 request, metadata = self._interceptor.pre_get_secret(request, metadata)
2347 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseGetSecret._get_transcoded_request(
2348 http_options, request
2349 )
2351 # Jsonify the query params
2352 query_params = _BaseSecretManagerServiceRestTransport._BaseGetSecret._get_query_params_json(
2353 transcoded_request
2354 )
2356 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2357 logging.DEBUG
2358 ): # pragma: NO COVER
2359 request_url = "{host}{uri}".format(
2360 host=self._host, uri=transcoded_request["uri"]
2361 )
2362 method = transcoded_request["method"]
2363 try:
2364 request_payload = type(request).to_json(request)
2365 except:
2366 request_payload = None
2367 http_request = {
2368 "payload": request_payload,
2369 "requestMethod": method,
2370 "requestUrl": request_url,
2371 "headers": dict(metadata),
2372 }
2373 _LOGGER.debug(
2374 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.GetSecret",
2375 extra={
2376 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2377 "rpcName": "GetSecret",
2378 "httpRequest": http_request,
2379 "metadata": http_request["headers"],
2380 },
2381 )
2383 # Send the request
2384 response = SecretManagerServiceRestTransport._GetSecret._get_response(
2385 self._host,
2386 metadata,
2387 query_params,
2388 self._session,
2389 timeout,
2390 transcoded_request,
2391 )
2393 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2394 # subclass.
2395 if response.status_code >= 400:
2396 raise core_exceptions.from_http_response(response)
2398 # Return the response
2399 resp = resources.Secret()
2400 pb_resp = resources.Secret.pb(resp)
2402 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2404 resp = self._interceptor.post_get_secret(resp)
2405 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2406 resp, _ = self._interceptor.post_get_secret_with_metadata(
2407 resp, response_metadata
2408 )
2409 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2410 logging.DEBUG
2411 ): # pragma: NO COVER
2412 try:
2413 response_payload = resources.Secret.to_json(response)
2414 except:
2415 response_payload = None
2416 http_response = {
2417 "payload": response_payload,
2418 "headers": dict(response.headers),
2419 "status": response.status_code,
2420 }
2421 _LOGGER.debug(
2422 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.get_secret",
2423 extra={
2424 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2425 "rpcName": "GetSecret",
2426 "metadata": http_response["headers"],
2427 "httpResponse": http_response,
2428 },
2429 )
2430 return resp
2432 class _GetSecretVersion(
2433 _BaseSecretManagerServiceRestTransport._BaseGetSecretVersion,
2434 SecretManagerServiceRestStub,
2435 ):
2436 def __hash__(self):
2437 return hash("SecretManagerServiceRestTransport.GetSecretVersion")
2439 @staticmethod
2440 def _get_response(
2441 host,
2442 metadata,
2443 query_params,
2444 session,
2445 timeout,
2446 transcoded_request,
2447 body=None,
2448 ):
2449 uri = transcoded_request["uri"]
2450 method = transcoded_request["method"]
2451 headers = dict(metadata)
2452 headers["Content-Type"] = "application/json"
2453 response = getattr(session, method)(
2454 "{host}{uri}".format(host=host, uri=uri),
2455 timeout=timeout,
2456 headers=headers,
2457 params=rest_helpers.flatten_query_params(query_params, strict=True),
2458 )
2459 return response
2461 def __call__(
2462 self,
2463 request: service.GetSecretVersionRequest,
2464 *,
2465 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2466 timeout: Optional[float] = None,
2467 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2468 ) -> resources.SecretVersion:
2469 r"""Call the get secret version method over HTTP.
2471 Args:
2472 request (~.service.GetSecretVersionRequest):
2473 The request object. Request message for
2474 [SecretManagerService.GetSecretVersion][google.cloud.secrets.v1beta1.SecretManagerService.GetSecretVersion].
2475 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2476 should be retried.
2477 timeout (float): The timeout for this request.
2478 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2479 sent along with the request as metadata. Normally, each value must be of type `str`,
2480 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2481 be of type `bytes`.
2483 Returns:
2484 ~.resources.SecretVersion:
2485 A secret version resource in the
2486 Secret Manager API.
2488 """
2490 http_options = _BaseSecretManagerServiceRestTransport._BaseGetSecretVersion._get_http_options()
2492 request, metadata = self._interceptor.pre_get_secret_version(
2493 request, metadata
2494 )
2495 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseGetSecretVersion._get_transcoded_request(
2496 http_options, request
2497 )
2499 # Jsonify the query params
2500 query_params = _BaseSecretManagerServiceRestTransport._BaseGetSecretVersion._get_query_params_json(
2501 transcoded_request
2502 )
2504 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2505 logging.DEBUG
2506 ): # pragma: NO COVER
2507 request_url = "{host}{uri}".format(
2508 host=self._host, uri=transcoded_request["uri"]
2509 )
2510 method = transcoded_request["method"]
2511 try:
2512 request_payload = type(request).to_json(request)
2513 except:
2514 request_payload = None
2515 http_request = {
2516 "payload": request_payload,
2517 "requestMethod": method,
2518 "requestUrl": request_url,
2519 "headers": dict(metadata),
2520 }
2521 _LOGGER.debug(
2522 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.GetSecretVersion",
2523 extra={
2524 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2525 "rpcName": "GetSecretVersion",
2526 "httpRequest": http_request,
2527 "metadata": http_request["headers"],
2528 },
2529 )
2531 # Send the request
2532 response = (
2533 SecretManagerServiceRestTransport._GetSecretVersion._get_response(
2534 self._host,
2535 metadata,
2536 query_params,
2537 self._session,
2538 timeout,
2539 transcoded_request,
2540 )
2541 )
2543 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2544 # subclass.
2545 if response.status_code >= 400:
2546 raise core_exceptions.from_http_response(response)
2548 # Return the response
2549 resp = resources.SecretVersion()
2550 pb_resp = resources.SecretVersion.pb(resp)
2552 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2554 resp = self._interceptor.post_get_secret_version(resp)
2555 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2556 resp, _ = self._interceptor.post_get_secret_version_with_metadata(
2557 resp, response_metadata
2558 )
2559 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2560 logging.DEBUG
2561 ): # pragma: NO COVER
2562 try:
2563 response_payload = resources.SecretVersion.to_json(response)
2564 except:
2565 response_payload = None
2566 http_response = {
2567 "payload": response_payload,
2568 "headers": dict(response.headers),
2569 "status": response.status_code,
2570 }
2571 _LOGGER.debug(
2572 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.get_secret_version",
2573 extra={
2574 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2575 "rpcName": "GetSecretVersion",
2576 "metadata": http_response["headers"],
2577 "httpResponse": http_response,
2578 },
2579 )
2580 return resp
2582 class _ListSecrets(
2583 _BaseSecretManagerServiceRestTransport._BaseListSecrets,
2584 SecretManagerServiceRestStub,
2585 ):
2586 def __hash__(self):
2587 return hash("SecretManagerServiceRestTransport.ListSecrets")
2589 @staticmethod
2590 def _get_response(
2591 host,
2592 metadata,
2593 query_params,
2594 session,
2595 timeout,
2596 transcoded_request,
2597 body=None,
2598 ):
2599 uri = transcoded_request["uri"]
2600 method = transcoded_request["method"]
2601 headers = dict(metadata)
2602 headers["Content-Type"] = "application/json"
2603 response = getattr(session, method)(
2604 "{host}{uri}".format(host=host, uri=uri),
2605 timeout=timeout,
2606 headers=headers,
2607 params=rest_helpers.flatten_query_params(query_params, strict=True),
2608 )
2609 return response
2611 def __call__(
2612 self,
2613 request: service.ListSecretsRequest,
2614 *,
2615 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2616 timeout: Optional[float] = None,
2617 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2618 ) -> service.ListSecretsResponse:
2619 r"""Call the list secrets method over HTTP.
2621 Args:
2622 request (~.service.ListSecretsRequest):
2623 The request object. Request message for
2624 [SecretManagerService.ListSecrets][google.cloud.secrets.v1beta1.SecretManagerService.ListSecrets].
2625 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2626 should be retried.
2627 timeout (float): The timeout for this request.
2628 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2629 sent along with the request as metadata. Normally, each value must be of type `str`,
2630 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2631 be of type `bytes`.
2633 Returns:
2634 ~.service.ListSecretsResponse:
2635 Response message for
2636 [SecretManagerService.ListSecrets][google.cloud.secrets.v1beta1.SecretManagerService.ListSecrets].
2638 """
2640 http_options = _BaseSecretManagerServiceRestTransport._BaseListSecrets._get_http_options()
2642 request, metadata = self._interceptor.pre_list_secrets(request, metadata)
2643 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseListSecrets._get_transcoded_request(
2644 http_options, request
2645 )
2647 # Jsonify the query params
2648 query_params = _BaseSecretManagerServiceRestTransport._BaseListSecrets._get_query_params_json(
2649 transcoded_request
2650 )
2652 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2653 logging.DEBUG
2654 ): # pragma: NO COVER
2655 request_url = "{host}{uri}".format(
2656 host=self._host, uri=transcoded_request["uri"]
2657 )
2658 method = transcoded_request["method"]
2659 try:
2660 request_payload = type(request).to_json(request)
2661 except:
2662 request_payload = None
2663 http_request = {
2664 "payload": request_payload,
2665 "requestMethod": method,
2666 "requestUrl": request_url,
2667 "headers": dict(metadata),
2668 }
2669 _LOGGER.debug(
2670 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.ListSecrets",
2671 extra={
2672 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2673 "rpcName": "ListSecrets",
2674 "httpRequest": http_request,
2675 "metadata": http_request["headers"],
2676 },
2677 )
2679 # Send the request
2680 response = SecretManagerServiceRestTransport._ListSecrets._get_response(
2681 self._host,
2682 metadata,
2683 query_params,
2684 self._session,
2685 timeout,
2686 transcoded_request,
2687 )
2689 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2690 # subclass.
2691 if response.status_code >= 400:
2692 raise core_exceptions.from_http_response(response)
2694 # Return the response
2695 resp = service.ListSecretsResponse()
2696 pb_resp = service.ListSecretsResponse.pb(resp)
2698 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2700 resp = self._interceptor.post_list_secrets(resp)
2701 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2702 resp, _ = self._interceptor.post_list_secrets_with_metadata(
2703 resp, response_metadata
2704 )
2705 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2706 logging.DEBUG
2707 ): # pragma: NO COVER
2708 try:
2709 response_payload = service.ListSecretsResponse.to_json(response)
2710 except:
2711 response_payload = None
2712 http_response = {
2713 "payload": response_payload,
2714 "headers": dict(response.headers),
2715 "status": response.status_code,
2716 }
2717 _LOGGER.debug(
2718 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.list_secrets",
2719 extra={
2720 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2721 "rpcName": "ListSecrets",
2722 "metadata": http_response["headers"],
2723 "httpResponse": http_response,
2724 },
2725 )
2726 return resp
2728 class _ListSecretVersions(
2729 _BaseSecretManagerServiceRestTransport._BaseListSecretVersions,
2730 SecretManagerServiceRestStub,
2731 ):
2732 def __hash__(self):
2733 return hash("SecretManagerServiceRestTransport.ListSecretVersions")
2735 @staticmethod
2736 def _get_response(
2737 host,
2738 metadata,
2739 query_params,
2740 session,
2741 timeout,
2742 transcoded_request,
2743 body=None,
2744 ):
2745 uri = transcoded_request["uri"]
2746 method = transcoded_request["method"]
2747 headers = dict(metadata)
2748 headers["Content-Type"] = "application/json"
2749 response = getattr(session, method)(
2750 "{host}{uri}".format(host=host, uri=uri),
2751 timeout=timeout,
2752 headers=headers,
2753 params=rest_helpers.flatten_query_params(query_params, strict=True),
2754 )
2755 return response
2757 def __call__(
2758 self,
2759 request: service.ListSecretVersionsRequest,
2760 *,
2761 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2762 timeout: Optional[float] = None,
2763 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2764 ) -> service.ListSecretVersionsResponse:
2765 r"""Call the list secret versions method over HTTP.
2767 Args:
2768 request (~.service.ListSecretVersionsRequest):
2769 The request object. Request message for
2770 [SecretManagerService.ListSecretVersions][google.cloud.secrets.v1beta1.SecretManagerService.ListSecretVersions].
2771 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2772 should be retried.
2773 timeout (float): The timeout for this request.
2774 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2775 sent along with the request as metadata. Normally, each value must be of type `str`,
2776 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2777 be of type `bytes`.
2779 Returns:
2780 ~.service.ListSecretVersionsResponse:
2781 Response message for
2782 [SecretManagerService.ListSecretVersions][google.cloud.secrets.v1beta1.SecretManagerService.ListSecretVersions].
2784 """
2786 http_options = _BaseSecretManagerServiceRestTransport._BaseListSecretVersions._get_http_options()
2788 request, metadata = self._interceptor.pre_list_secret_versions(
2789 request, metadata
2790 )
2791 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseListSecretVersions._get_transcoded_request(
2792 http_options, request
2793 )
2795 # Jsonify the query params
2796 query_params = _BaseSecretManagerServiceRestTransport._BaseListSecretVersions._get_query_params_json(
2797 transcoded_request
2798 )
2800 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2801 logging.DEBUG
2802 ): # pragma: NO COVER
2803 request_url = "{host}{uri}".format(
2804 host=self._host, uri=transcoded_request["uri"]
2805 )
2806 method = transcoded_request["method"]
2807 try:
2808 request_payload = type(request).to_json(request)
2809 except:
2810 request_payload = None
2811 http_request = {
2812 "payload": request_payload,
2813 "requestMethod": method,
2814 "requestUrl": request_url,
2815 "headers": dict(metadata),
2816 }
2817 _LOGGER.debug(
2818 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.ListSecretVersions",
2819 extra={
2820 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2821 "rpcName": "ListSecretVersions",
2822 "httpRequest": http_request,
2823 "metadata": http_request["headers"],
2824 },
2825 )
2827 # Send the request
2828 response = (
2829 SecretManagerServiceRestTransport._ListSecretVersions._get_response(
2830 self._host,
2831 metadata,
2832 query_params,
2833 self._session,
2834 timeout,
2835 transcoded_request,
2836 )
2837 )
2839 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
2840 # subclass.
2841 if response.status_code >= 400:
2842 raise core_exceptions.from_http_response(response)
2844 # Return the response
2845 resp = service.ListSecretVersionsResponse()
2846 pb_resp = service.ListSecretVersionsResponse.pb(resp)
2848 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
2850 resp = self._interceptor.post_list_secret_versions(resp)
2851 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
2852 resp, _ = self._interceptor.post_list_secret_versions_with_metadata(
2853 resp, response_metadata
2854 )
2855 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
2856 logging.DEBUG
2857 ): # pragma: NO COVER
2858 try:
2859 response_payload = service.ListSecretVersionsResponse.to_json(
2860 response
2861 )
2862 except:
2863 response_payload = None
2864 http_response = {
2865 "payload": response_payload,
2866 "headers": dict(response.headers),
2867 "status": response.status_code,
2868 }
2869 _LOGGER.debug(
2870 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.list_secret_versions",
2871 extra={
2872 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
2873 "rpcName": "ListSecretVersions",
2874 "metadata": http_response["headers"],
2875 "httpResponse": http_response,
2876 },
2877 )
2878 return resp
2880 class _SetIamPolicy(
2881 _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy,
2882 SecretManagerServiceRestStub,
2883 ):
2884 def __hash__(self):
2885 return hash("SecretManagerServiceRestTransport.SetIamPolicy")
2887 @staticmethod
2888 def _get_response(
2889 host,
2890 metadata,
2891 query_params,
2892 session,
2893 timeout,
2894 transcoded_request,
2895 body=None,
2896 ):
2897 uri = transcoded_request["uri"]
2898 method = transcoded_request["method"]
2899 headers = dict(metadata)
2900 headers["Content-Type"] = "application/json"
2901 response = getattr(session, method)(
2902 "{host}{uri}".format(host=host, uri=uri),
2903 timeout=timeout,
2904 headers=headers,
2905 params=rest_helpers.flatten_query_params(query_params, strict=True),
2906 data=body,
2907 )
2908 return response
2910 def __call__(
2911 self,
2912 request: iam_policy_pb2.SetIamPolicyRequest,
2913 *,
2914 retry: OptionalRetry = gapic_v1.method.DEFAULT,
2915 timeout: Optional[float] = None,
2916 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
2917 ) -> policy_pb2.Policy:
2918 r"""Call the set iam policy method over HTTP.
2920 Args:
2921 request (~.iam_policy_pb2.SetIamPolicyRequest):
2922 The request object. Request message for ``SetIamPolicy`` method.
2923 retry (google.api_core.retry.Retry): Designation of what errors, if any,
2924 should be retried.
2925 timeout (float): The timeout for this request.
2926 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
2927 sent along with the request as metadata. Normally, each value must be of type `str`,
2928 but for metadata keys ending with the suffix `-bin`, the corresponding values must
2929 be of type `bytes`.
2931 Returns:
2932 ~.policy_pb2.Policy:
2933 An Identity and Access Management (IAM) policy, which
2934 specifies access controls for Google Cloud resources.
2936 A ``Policy`` is a collection of ``bindings``. A
2937 ``binding`` binds one or more ``members``, or
2938 principals, to a single ``role``. Principals can be user
2939 accounts, service accounts, Google groups, and domains
2940 (such as G Suite). A ``role`` is a named list of
2941 permissions; each ``role`` can be an IAM predefined role
2942 or a user-created custom role.
2944 For some types of Google Cloud resources, a ``binding``
2945 can also specify a ``condition``, which is a logical
2946 expression that allows access to a resource only if the
2947 expression evaluates to ``true``. A condition can add
2948 constraints based on attributes of the request, the
2949 resource, or both. To learn which resources support
2950 conditions in their IAM policies, see the `IAM
2951 documentation <https://cloud.google.com/iam/help/conditions/resource-policies>`__.
2953 **JSON example:**
2955 ::
2957 {
2958 "bindings": [
2959 {
2960 "role": "roles/resourcemanager.organizationAdmin",
2961 "members": [
2962 "user:mike@example.com",
2963 "group:admins@example.com",
2964 "domain:google.com",
2965 "serviceAccount:my-project-id@appspot.gserviceaccount.com"
2966 ]
2967 },
2968 {
2969 "role": "roles/resourcemanager.organizationViewer",
2970 "members": [
2971 "user:eve@example.com"
2972 ],
2973 "condition": {
2974 "title": "expirable access",
2975 "description": "Does not grant access after Sep 2020",
2976 "expression": "request.time <
2977 timestamp('2020-10-01T00:00:00.000Z')",
2978 }
2979 }
2980 ],
2981 "etag": "BwWWja0YfJA=",
2982 "version": 3
2983 }
2985 **YAML example:**
2987 ::
2989 bindings:
2990 - members:
2991 - user:mike@example.com
2992 - group:admins@example.com
2993 - domain:google.com
2994 - serviceAccount:my-project-id@appspot.gserviceaccount.com
2995 role: roles/resourcemanager.organizationAdmin
2996 - members:
2997 - user:eve@example.com
2998 role: roles/resourcemanager.organizationViewer
2999 condition:
3000 title: expirable access
3001 description: Does not grant access after Sep 2020
3002 expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
3003 etag: BwWWja0YfJA=
3004 version: 3
3006 For a description of IAM and its features, see the `IAM
3007 documentation <https://cloud.google.com/iam/docs/>`__.
3009 """
3011 http_options = _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy._get_http_options()
3013 request, metadata = self._interceptor.pre_set_iam_policy(request, metadata)
3014 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy._get_transcoded_request(
3015 http_options, request
3016 )
3018 body = _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy._get_request_body_json(
3019 transcoded_request
3020 )
3022 # Jsonify the query params
3023 query_params = _BaseSecretManagerServiceRestTransport._BaseSetIamPolicy._get_query_params_json(
3024 transcoded_request
3025 )
3027 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3028 logging.DEBUG
3029 ): # pragma: NO COVER
3030 request_url = "{host}{uri}".format(
3031 host=self._host, uri=transcoded_request["uri"]
3032 )
3033 method = transcoded_request["method"]
3034 try:
3035 request_payload = json_format.MessageToJson(request)
3036 except:
3037 request_payload = None
3038 http_request = {
3039 "payload": request_payload,
3040 "requestMethod": method,
3041 "requestUrl": request_url,
3042 "headers": dict(metadata),
3043 }
3044 _LOGGER.debug(
3045 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.SetIamPolicy",
3046 extra={
3047 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3048 "rpcName": "SetIamPolicy",
3049 "httpRequest": http_request,
3050 "metadata": http_request["headers"],
3051 },
3052 )
3054 # Send the request
3055 response = SecretManagerServiceRestTransport._SetIamPolicy._get_response(
3056 self._host,
3057 metadata,
3058 query_params,
3059 self._session,
3060 timeout,
3061 transcoded_request,
3062 body,
3063 )
3065 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3066 # subclass.
3067 if response.status_code >= 400:
3068 raise core_exceptions.from_http_response(response)
3070 # Return the response
3071 resp = policy_pb2.Policy()
3072 pb_resp = resp
3074 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
3076 resp = self._interceptor.post_set_iam_policy(resp)
3077 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
3078 resp, _ = self._interceptor.post_set_iam_policy_with_metadata(
3079 resp, response_metadata
3080 )
3081 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3082 logging.DEBUG
3083 ): # pragma: NO COVER
3084 try:
3085 response_payload = json_format.MessageToJson(resp)
3086 except:
3087 response_payload = None
3088 http_response = {
3089 "payload": response_payload,
3090 "headers": dict(response.headers),
3091 "status": response.status_code,
3092 }
3093 _LOGGER.debug(
3094 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.set_iam_policy",
3095 extra={
3096 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3097 "rpcName": "SetIamPolicy",
3098 "metadata": http_response["headers"],
3099 "httpResponse": http_response,
3100 },
3101 )
3102 return resp
3104 class _TestIamPermissions(
3105 _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions,
3106 SecretManagerServiceRestStub,
3107 ):
3108 def __hash__(self):
3109 return hash("SecretManagerServiceRestTransport.TestIamPermissions")
3111 @staticmethod
3112 def _get_response(
3113 host,
3114 metadata,
3115 query_params,
3116 session,
3117 timeout,
3118 transcoded_request,
3119 body=None,
3120 ):
3121 uri = transcoded_request["uri"]
3122 method = transcoded_request["method"]
3123 headers = dict(metadata)
3124 headers["Content-Type"] = "application/json"
3125 response = getattr(session, method)(
3126 "{host}{uri}".format(host=host, uri=uri),
3127 timeout=timeout,
3128 headers=headers,
3129 params=rest_helpers.flatten_query_params(query_params, strict=True),
3130 data=body,
3131 )
3132 return response
3134 def __call__(
3135 self,
3136 request: iam_policy_pb2.TestIamPermissionsRequest,
3137 *,
3138 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3139 timeout: Optional[float] = None,
3140 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
3141 ) -> iam_policy_pb2.TestIamPermissionsResponse:
3142 r"""Call the test iam permissions method over HTTP.
3144 Args:
3145 request (~.iam_policy_pb2.TestIamPermissionsRequest):
3146 The request object. Request message for ``TestIamPermissions`` method.
3147 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3148 should be retried.
3149 timeout (float): The timeout for this request.
3150 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
3151 sent along with the request as metadata. Normally, each value must be of type `str`,
3152 but for metadata keys ending with the suffix `-bin`, the corresponding values must
3153 be of type `bytes`.
3155 Returns:
3156 ~.iam_policy_pb2.TestIamPermissionsResponse:
3157 Response message for ``TestIamPermissions`` method.
3158 """
3160 http_options = _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions._get_http_options()
3162 request, metadata = self._interceptor.pre_test_iam_permissions(
3163 request, metadata
3164 )
3165 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions._get_transcoded_request(
3166 http_options, request
3167 )
3169 body = _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions._get_request_body_json(
3170 transcoded_request
3171 )
3173 # Jsonify the query params
3174 query_params = _BaseSecretManagerServiceRestTransport._BaseTestIamPermissions._get_query_params_json(
3175 transcoded_request
3176 )
3178 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3179 logging.DEBUG
3180 ): # pragma: NO COVER
3181 request_url = "{host}{uri}".format(
3182 host=self._host, uri=transcoded_request["uri"]
3183 )
3184 method = transcoded_request["method"]
3185 try:
3186 request_payload = json_format.MessageToJson(request)
3187 except:
3188 request_payload = None
3189 http_request = {
3190 "payload": request_payload,
3191 "requestMethod": method,
3192 "requestUrl": request_url,
3193 "headers": dict(metadata),
3194 }
3195 _LOGGER.debug(
3196 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.TestIamPermissions",
3197 extra={
3198 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3199 "rpcName": "TestIamPermissions",
3200 "httpRequest": http_request,
3201 "metadata": http_request["headers"],
3202 },
3203 )
3205 # Send the request
3206 response = (
3207 SecretManagerServiceRestTransport._TestIamPermissions._get_response(
3208 self._host,
3209 metadata,
3210 query_params,
3211 self._session,
3212 timeout,
3213 transcoded_request,
3214 body,
3215 )
3216 )
3218 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3219 # subclass.
3220 if response.status_code >= 400:
3221 raise core_exceptions.from_http_response(response)
3223 # Return the response
3224 resp = iam_policy_pb2.TestIamPermissionsResponse()
3225 pb_resp = resp
3227 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
3229 resp = self._interceptor.post_test_iam_permissions(resp)
3230 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
3231 resp, _ = self._interceptor.post_test_iam_permissions_with_metadata(
3232 resp, response_metadata
3233 )
3234 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3235 logging.DEBUG
3236 ): # pragma: NO COVER
3237 try:
3238 response_payload = json_format.MessageToJson(resp)
3239 except:
3240 response_payload = None
3241 http_response = {
3242 "payload": response_payload,
3243 "headers": dict(response.headers),
3244 "status": response.status_code,
3245 }
3246 _LOGGER.debug(
3247 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.test_iam_permissions",
3248 extra={
3249 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3250 "rpcName": "TestIamPermissions",
3251 "metadata": http_response["headers"],
3252 "httpResponse": http_response,
3253 },
3254 )
3255 return resp
3257 class _UpdateSecret(
3258 _BaseSecretManagerServiceRestTransport._BaseUpdateSecret,
3259 SecretManagerServiceRestStub,
3260 ):
3261 def __hash__(self):
3262 return hash("SecretManagerServiceRestTransport.UpdateSecret")
3264 @staticmethod
3265 def _get_response(
3266 host,
3267 metadata,
3268 query_params,
3269 session,
3270 timeout,
3271 transcoded_request,
3272 body=None,
3273 ):
3274 uri = transcoded_request["uri"]
3275 method = transcoded_request["method"]
3276 headers = dict(metadata)
3277 headers["Content-Type"] = "application/json"
3278 response = getattr(session, method)(
3279 "{host}{uri}".format(host=host, uri=uri),
3280 timeout=timeout,
3281 headers=headers,
3282 params=rest_helpers.flatten_query_params(query_params, strict=True),
3283 data=body,
3284 )
3285 return response
3287 def __call__(
3288 self,
3289 request: service.UpdateSecretRequest,
3290 *,
3291 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3292 timeout: Optional[float] = None,
3293 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
3294 ) -> resources.Secret:
3295 r"""Call the update secret method over HTTP.
3297 Args:
3298 request (~.service.UpdateSecretRequest):
3299 The request object. Request message for
3300 [SecretManagerService.UpdateSecret][google.cloud.secrets.v1beta1.SecretManagerService.UpdateSecret].
3301 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3302 should be retried.
3303 timeout (float): The timeout for this request.
3304 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
3305 sent along with the request as metadata. Normally, each value must be of type `str`,
3306 but for metadata keys ending with the suffix `-bin`, the corresponding values must
3307 be of type `bytes`.
3309 Returns:
3310 ~.resources.Secret:
3311 A [Secret][google.cloud.secrets.v1beta1.Secret] is a
3312 logical secret whose value and versions can be accessed.
3314 A [Secret][google.cloud.secrets.v1beta1.Secret] is made
3315 up of zero or more
3316 [SecretVersions][google.cloud.secrets.v1beta1.SecretVersion]
3317 that represent the secret data.
3319 """
3321 http_options = _BaseSecretManagerServiceRestTransport._BaseUpdateSecret._get_http_options()
3323 request, metadata = self._interceptor.pre_update_secret(request, metadata)
3324 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseUpdateSecret._get_transcoded_request(
3325 http_options, request
3326 )
3328 body = _BaseSecretManagerServiceRestTransport._BaseUpdateSecret._get_request_body_json(
3329 transcoded_request
3330 )
3332 # Jsonify the query params
3333 query_params = _BaseSecretManagerServiceRestTransport._BaseUpdateSecret._get_query_params_json(
3334 transcoded_request
3335 )
3337 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3338 logging.DEBUG
3339 ): # pragma: NO COVER
3340 request_url = "{host}{uri}".format(
3341 host=self._host, uri=transcoded_request["uri"]
3342 )
3343 method = transcoded_request["method"]
3344 try:
3345 request_payload = type(request).to_json(request)
3346 except:
3347 request_payload = None
3348 http_request = {
3349 "payload": request_payload,
3350 "requestMethod": method,
3351 "requestUrl": request_url,
3352 "headers": dict(metadata),
3353 }
3354 _LOGGER.debug(
3355 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.UpdateSecret",
3356 extra={
3357 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3358 "rpcName": "UpdateSecret",
3359 "httpRequest": http_request,
3360 "metadata": http_request["headers"],
3361 },
3362 )
3364 # Send the request
3365 response = SecretManagerServiceRestTransport._UpdateSecret._get_response(
3366 self._host,
3367 metadata,
3368 query_params,
3369 self._session,
3370 timeout,
3371 transcoded_request,
3372 body,
3373 )
3375 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3376 # subclass.
3377 if response.status_code >= 400:
3378 raise core_exceptions.from_http_response(response)
3380 # Return the response
3381 resp = resources.Secret()
3382 pb_resp = resources.Secret.pb(resp)
3384 json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
3386 resp = self._interceptor.post_update_secret(resp)
3387 response_metadata = [(k, str(v)) for k, v in response.headers.items()]
3388 resp, _ = self._interceptor.post_update_secret_with_metadata(
3389 resp, response_metadata
3390 )
3391 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3392 logging.DEBUG
3393 ): # pragma: NO COVER
3394 try:
3395 response_payload = resources.Secret.to_json(response)
3396 except:
3397 response_payload = None
3398 http_response = {
3399 "payload": response_payload,
3400 "headers": dict(response.headers),
3401 "status": response.status_code,
3402 }
3403 _LOGGER.debug(
3404 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceClient.update_secret",
3405 extra={
3406 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3407 "rpcName": "UpdateSecret",
3408 "metadata": http_response["headers"],
3409 "httpResponse": http_response,
3410 },
3411 )
3412 return resp
3414 @property
3415 def access_secret_version(
3416 self,
3417 ) -> Callable[
3418 [service.AccessSecretVersionRequest], service.AccessSecretVersionResponse
3419 ]:
3420 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3421 # In C++ this would require a dynamic_cast
3422 return self._AccessSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3424 @property
3425 def add_secret_version(
3426 self,
3427 ) -> Callable[[service.AddSecretVersionRequest], resources.SecretVersion]:
3428 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3429 # In C++ this would require a dynamic_cast
3430 return self._AddSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3432 @property
3433 def create_secret(
3434 self,
3435 ) -> Callable[[service.CreateSecretRequest], resources.Secret]:
3436 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3437 # In C++ this would require a dynamic_cast
3438 return self._CreateSecret(self._session, self._host, self._interceptor) # type: ignore
3440 @property
3441 def delete_secret(self) -> Callable[[service.DeleteSecretRequest], empty_pb2.Empty]:
3442 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3443 # In C++ this would require a dynamic_cast
3444 return self._DeleteSecret(self._session, self._host, self._interceptor) # type: ignore
3446 @property
3447 def destroy_secret_version(
3448 self,
3449 ) -> Callable[[service.DestroySecretVersionRequest], resources.SecretVersion]:
3450 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3451 # In C++ this would require a dynamic_cast
3452 return self._DestroySecretVersion(self._session, self._host, self._interceptor) # type: ignore
3454 @property
3455 def disable_secret_version(
3456 self,
3457 ) -> Callable[[service.DisableSecretVersionRequest], resources.SecretVersion]:
3458 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3459 # In C++ this would require a dynamic_cast
3460 return self._DisableSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3462 @property
3463 def enable_secret_version(
3464 self,
3465 ) -> Callable[[service.EnableSecretVersionRequest], resources.SecretVersion]:
3466 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3467 # In C++ this would require a dynamic_cast
3468 return self._EnableSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3470 @property
3471 def get_iam_policy(
3472 self,
3473 ) -> Callable[[iam_policy_pb2.GetIamPolicyRequest], policy_pb2.Policy]:
3474 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3475 # In C++ this would require a dynamic_cast
3476 return self._GetIamPolicy(self._session, self._host, self._interceptor) # type: ignore
3478 @property
3479 def get_secret(self) -> Callable[[service.GetSecretRequest], resources.Secret]:
3480 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3481 # In C++ this would require a dynamic_cast
3482 return self._GetSecret(self._session, self._host, self._interceptor) # type: ignore
3484 @property
3485 def get_secret_version(
3486 self,
3487 ) -> Callable[[service.GetSecretVersionRequest], resources.SecretVersion]:
3488 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3489 # In C++ this would require a dynamic_cast
3490 return self._GetSecretVersion(self._session, self._host, self._interceptor) # type: ignore
3492 @property
3493 def list_secrets(
3494 self,
3495 ) -> Callable[[service.ListSecretsRequest], service.ListSecretsResponse]:
3496 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3497 # In C++ this would require a dynamic_cast
3498 return self._ListSecrets(self._session, self._host, self._interceptor) # type: ignore
3500 @property
3501 def list_secret_versions(
3502 self,
3503 ) -> Callable[
3504 [service.ListSecretVersionsRequest], service.ListSecretVersionsResponse
3505 ]:
3506 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3507 # In C++ this would require a dynamic_cast
3508 return self._ListSecretVersions(self._session, self._host, self._interceptor) # type: ignore
3510 @property
3511 def set_iam_policy(
3512 self,
3513 ) -> Callable[[iam_policy_pb2.SetIamPolicyRequest], policy_pb2.Policy]:
3514 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3515 # In C++ this would require a dynamic_cast
3516 return self._SetIamPolicy(self._session, self._host, self._interceptor) # type: ignore
3518 @property
3519 def test_iam_permissions(
3520 self,
3521 ) -> Callable[
3522 [iam_policy_pb2.TestIamPermissionsRequest],
3523 iam_policy_pb2.TestIamPermissionsResponse,
3524 ]:
3525 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3526 # In C++ this would require a dynamic_cast
3527 return self._TestIamPermissions(self._session, self._host, self._interceptor) # type: ignore
3529 @property
3530 def update_secret(
3531 self,
3532 ) -> Callable[[service.UpdateSecretRequest], resources.Secret]:
3533 # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
3534 # In C++ this would require a dynamic_cast
3535 return self._UpdateSecret(self._session, self._host, self._interceptor) # type: ignore
3537 @property
3538 def get_location(self):
3539 return self._GetLocation(self._session, self._host, self._interceptor) # type: ignore
3541 class _GetLocation(
3542 _BaseSecretManagerServiceRestTransport._BaseGetLocation,
3543 SecretManagerServiceRestStub,
3544 ):
3545 def __hash__(self):
3546 return hash("SecretManagerServiceRestTransport.GetLocation")
3548 @staticmethod
3549 def _get_response(
3550 host,
3551 metadata,
3552 query_params,
3553 session,
3554 timeout,
3555 transcoded_request,
3556 body=None,
3557 ):
3558 uri = transcoded_request["uri"]
3559 method = transcoded_request["method"]
3560 headers = dict(metadata)
3561 headers["Content-Type"] = "application/json"
3562 response = getattr(session, method)(
3563 "{host}{uri}".format(host=host, uri=uri),
3564 timeout=timeout,
3565 headers=headers,
3566 params=rest_helpers.flatten_query_params(query_params, strict=True),
3567 )
3568 return response
3570 def __call__(
3571 self,
3572 request: locations_pb2.GetLocationRequest,
3573 *,
3574 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3575 timeout: Optional[float] = None,
3576 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
3577 ) -> locations_pb2.Location:
3578 r"""Call the get location method over HTTP.
3580 Args:
3581 request (locations_pb2.GetLocationRequest):
3582 The request object for GetLocation method.
3583 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3584 should be retried.
3585 timeout (float): The timeout for this request.
3586 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
3587 sent along with the request as metadata. Normally, each value must be of type `str`,
3588 but for metadata keys ending with the suffix `-bin`, the corresponding values must
3589 be of type `bytes`.
3591 Returns:
3592 locations_pb2.Location: Response from GetLocation method.
3593 """
3595 http_options = _BaseSecretManagerServiceRestTransport._BaseGetLocation._get_http_options()
3597 request, metadata = self._interceptor.pre_get_location(request, metadata)
3598 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseGetLocation._get_transcoded_request(
3599 http_options, request
3600 )
3602 # Jsonify the query params
3603 query_params = _BaseSecretManagerServiceRestTransport._BaseGetLocation._get_query_params_json(
3604 transcoded_request
3605 )
3607 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3608 logging.DEBUG
3609 ): # pragma: NO COVER
3610 request_url = "{host}{uri}".format(
3611 host=self._host, uri=transcoded_request["uri"]
3612 )
3613 method = transcoded_request["method"]
3614 try:
3615 request_payload = json_format.MessageToJson(request)
3616 except:
3617 request_payload = None
3618 http_request = {
3619 "payload": request_payload,
3620 "requestMethod": method,
3621 "requestUrl": request_url,
3622 "headers": dict(metadata),
3623 }
3624 _LOGGER.debug(
3625 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.GetLocation",
3626 extra={
3627 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3628 "rpcName": "GetLocation",
3629 "httpRequest": http_request,
3630 "metadata": http_request["headers"],
3631 },
3632 )
3634 # Send the request
3635 response = SecretManagerServiceRestTransport._GetLocation._get_response(
3636 self._host,
3637 metadata,
3638 query_params,
3639 self._session,
3640 timeout,
3641 transcoded_request,
3642 )
3644 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3645 # subclass.
3646 if response.status_code >= 400:
3647 raise core_exceptions.from_http_response(response)
3649 content = response.content.decode("utf-8")
3650 resp = locations_pb2.Location()
3651 resp = json_format.Parse(content, resp)
3652 resp = self._interceptor.post_get_location(resp)
3653 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3654 logging.DEBUG
3655 ): # pragma: NO COVER
3656 try:
3657 response_payload = json_format.MessageToJson(resp)
3658 except:
3659 response_payload = None
3660 http_response = {
3661 "payload": response_payload,
3662 "headers": dict(response.headers),
3663 "status": response.status_code,
3664 }
3665 _LOGGER.debug(
3666 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceAsyncClient.GetLocation",
3667 extra={
3668 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3669 "rpcName": "GetLocation",
3670 "httpResponse": http_response,
3671 "metadata": http_response["headers"],
3672 },
3673 )
3674 return resp
3676 @property
3677 def list_locations(self):
3678 return self._ListLocations(self._session, self._host, self._interceptor) # type: ignore
3680 class _ListLocations(
3681 _BaseSecretManagerServiceRestTransport._BaseListLocations,
3682 SecretManagerServiceRestStub,
3683 ):
3684 def __hash__(self):
3685 return hash("SecretManagerServiceRestTransport.ListLocations")
3687 @staticmethod
3688 def _get_response(
3689 host,
3690 metadata,
3691 query_params,
3692 session,
3693 timeout,
3694 transcoded_request,
3695 body=None,
3696 ):
3697 uri = transcoded_request["uri"]
3698 method = transcoded_request["method"]
3699 headers = dict(metadata)
3700 headers["Content-Type"] = "application/json"
3701 response = getattr(session, method)(
3702 "{host}{uri}".format(host=host, uri=uri),
3703 timeout=timeout,
3704 headers=headers,
3705 params=rest_helpers.flatten_query_params(query_params, strict=True),
3706 )
3707 return response
3709 def __call__(
3710 self,
3711 request: locations_pb2.ListLocationsRequest,
3712 *,
3713 retry: OptionalRetry = gapic_v1.method.DEFAULT,
3714 timeout: Optional[float] = None,
3715 metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
3716 ) -> locations_pb2.ListLocationsResponse:
3717 r"""Call the list locations method over HTTP.
3719 Args:
3720 request (locations_pb2.ListLocationsRequest):
3721 The request object for ListLocations method.
3722 retry (google.api_core.retry.Retry): Designation of what errors, if any,
3723 should be retried.
3724 timeout (float): The timeout for this request.
3725 metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
3726 sent along with the request as metadata. Normally, each value must be of type `str`,
3727 but for metadata keys ending with the suffix `-bin`, the corresponding values must
3728 be of type `bytes`.
3730 Returns:
3731 locations_pb2.ListLocationsResponse: Response from ListLocations method.
3732 """
3734 http_options = _BaseSecretManagerServiceRestTransport._BaseListLocations._get_http_options()
3736 request, metadata = self._interceptor.pre_list_locations(request, metadata)
3737 transcoded_request = _BaseSecretManagerServiceRestTransport._BaseListLocations._get_transcoded_request(
3738 http_options, request
3739 )
3741 # Jsonify the query params
3742 query_params = _BaseSecretManagerServiceRestTransport._BaseListLocations._get_query_params_json(
3743 transcoded_request
3744 )
3746 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3747 logging.DEBUG
3748 ): # pragma: NO COVER
3749 request_url = "{host}{uri}".format(
3750 host=self._host, uri=transcoded_request["uri"]
3751 )
3752 method = transcoded_request["method"]
3753 try:
3754 request_payload = json_format.MessageToJson(request)
3755 except:
3756 request_payload = None
3757 http_request = {
3758 "payload": request_payload,
3759 "requestMethod": method,
3760 "requestUrl": request_url,
3761 "headers": dict(metadata),
3762 }
3763 _LOGGER.debug(
3764 f"Sending request for google.cloud.secrets_v1beta1.SecretManagerServiceClient.ListLocations",
3765 extra={
3766 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3767 "rpcName": "ListLocations",
3768 "httpRequest": http_request,
3769 "metadata": http_request["headers"],
3770 },
3771 )
3773 # Send the request
3774 response = SecretManagerServiceRestTransport._ListLocations._get_response(
3775 self._host,
3776 metadata,
3777 query_params,
3778 self._session,
3779 timeout,
3780 transcoded_request,
3781 )
3783 # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
3784 # subclass.
3785 if response.status_code >= 400:
3786 raise core_exceptions.from_http_response(response)
3788 content = response.content.decode("utf-8")
3789 resp = locations_pb2.ListLocationsResponse()
3790 resp = json_format.Parse(content, resp)
3791 resp = self._interceptor.post_list_locations(resp)
3792 if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
3793 logging.DEBUG
3794 ): # pragma: NO COVER
3795 try:
3796 response_payload = json_format.MessageToJson(resp)
3797 except:
3798 response_payload = None
3799 http_response = {
3800 "payload": response_payload,
3801 "headers": dict(response.headers),
3802 "status": response.status_code,
3803 }
3804 _LOGGER.debug(
3805 "Received response for google.cloud.secrets_v1beta1.SecretManagerServiceAsyncClient.ListLocations",
3806 extra={
3807 "serviceName": "google.cloud.secrets.v1beta1.SecretManagerService",
3808 "rpcName": "ListLocations",
3809 "httpResponse": http_response,
3810 "metadata": http_response["headers"],
3811 },
3812 )
3813 return resp
3815 @property
3816 def kind(self) -> str:
3817 return "rest"
3819 def close(self):
3820 self._session.close()
3823__all__ = ("SecretManagerServiceRestTransport",)